tools Namespace Reference

Various Tools. More...

Namespaces
	base58
	detail
	dns_utils
	error
	wallet_rpc

Classes
class	options
class	Combinator
class	scoped_ptr
struct	DNSResolverData
class	string_copy
class	DNSResolver
	Provides high-level access to DNS resolution. More...
struct	download_thread_control
class	t_http_connection
class	Notify
class	password_container
struct	login
class	PerformanceTimer
class	LoggingPerformanceTimer
class	t_rpc_client
class	scoped_message_writer
class	threadpool
	A global thread pool. More...
struct	close_file
	Functional class for closing C file handles. More...
class	private_file
	A file restricted to process owner AND process. Deletes file on destruction. More...
class	file_locker
class	signal_handler
	Defines a signal handler for win32 and *nix. More...
class	NodeRPCProxy
class	ringdb
class	gamma_picker
class	wallet_keys_unlocker
class	i_wallet2_callback
class	wallet_device_callback
struct	tx_dust_policy
class	hashchain
class	wallet2
struct	COMMAND_RPC_GET_ADDRESS_TXS
struct	COMMAND_RPC_GET_ADDRESS_INFO
struct	COMMAND_RPC_GET_UNSPENT_OUTS
struct	COMMAND_RPC_LOGIN
struct	COMMAND_RPC_IMPORT_WALLET_REQUEST
class	wallet_rpc_server

Typedefs
typedef class scoped_ptr< ub_result, ub_resolve_free >	ub_result_ptr
typedef std::shared_ptr< download_thread_control >	download_async_handle

Enumerations
enum	{ EVARINT_OVERFLOW = -1 , EVARINT_REPRESENT = -2 }
	Error codes for varint. More...

Functions
template<typename F >
void	apply_permutation (std::vector< size_t > permutation, const F &swap)
template<typename T >
void	apply_permutation (const std::vector< size_t > &permutation, std::vector< T > &v)
template<class t_object >
bool	serialize_obj_to_file (t_object &obj, const std::string &file_path)
template<class t_object >
bool	unserialize_obj_from_file (t_object &obj, const std::string &file_path)
uint64_t	combinations_count (uint32_t k, uint32_t n)
boost::optional< std::string >	ipv4_to_string (const char *src, size_t len)
boost::optional< std::string >	ipv6_to_string (const char *src, size_t len)
boost::optional< std::string >	txt_to_string (const char *src, size_t len)
bool	download (const std::string &path, const std::string &url, std::function< bool(const std::string &, const std::string &, size_t, ssize_t)> cb)
download_async_handle	download_async (const std::string &path, const std::string &url, std::function< void(const std::string &, const std::string &, bool)> result, std::function< bool(const std::string &, const std::string &, size_t, ssize_t)> progress)
bool	download_finished (const download_async_handle &control)
bool	download_error (const download_async_handle &control)
bool	download_wait (const download_async_handle &control)
bool	download_cancel (const download_async_handle &control)
uint64_t	get_tick_count ()
uint64_t	ticks_to_ns (uint64_t ticks)
void	set_performance_timer_log_level (el::Level level)
uint64_t	get_ticks_per_ns ()
uint32_t	make_pruning_seed (uint32_t stripe, uint32_t log_stripes)
bool	has_unpruned_block (uint64_t block_height, uint64_t blockchain_height, uint32_t pruning_seed)
uint32_t	get_pruning_stripe (uint64_t block_height, uint64_t blockchain_height, uint32_t log_stripes)
uint32_t	get_pruning_seed (uint64_t block_height, uint64_t blockchain_height, uint32_t log_stripes)
uint64_t	get_next_unpruned_block_height (uint64_t block_height, uint64_t blockchain_height, uint32_t pruning_seed)
uint64_t	get_next_pruned_block_height (uint64_t block_height, uint64_t blockchain_height, uint32_t pruning_seed)
uint32_t	get_random_stripe ()
constexpr uint32_t	get_pruning_log_stripes (uint32_t pruning_seed)
uint32_t	get_pruning_stripe (uint32_t pruning_seed)
scoped_message_writer	success_msg_writer (bool color=true)
scoped_message_writer	msg_writer (epee::console_colors color=epee::console_color_default)
scoped_message_writer	fail_msg_writer ()
int	spawn (const char *filename, const std::vector< std::string > &args, bool wait)
void	set_stack_trace_log (const std::string &log)
void	log_stack_trace (const char *msg)
bool	check_updates (const std::string &software, const std::string &buildtag, std::string &version, std::string &hash)
std::string	get_update_url (const std::string &software, const std::string &subdir, const std::string &buildtag, const std::string &version, bool user)
std::string	get_nix_version_display_string ()
std::string	get_os_version_string ()
	Returns the OS version string. More...
std::string	get_default_data_dir ()
	Returns the default data directory. More...
bool	create_directories_if_necessary (const std::string &path)
	creates directories for a path More...
std::error_code	replace_file (const std::string &old_name, const std::string &new_name)
	std::rename wrapper for nix and something strange for windows. More...
bool	sanitize_locale ()
bool	disable_core_dumps ()
ssize_t	get_lockable_memory ()
bool	on_startup ()
void	set_strict_default_file_permissions (bool strict)
boost::optional< bool >	is_hdd (const char *file_path)
void	set_max_concurrency (unsigned n)
unsigned	get_max_concurrency ()
bool	is_local_address (const std::string &address)
int	vercmp (const char *v0, const char *v1)
bool	sha256sum (const uint8_t *data, size_t len, crypto::hash &hash)
bool	sha256sum (const std::string &filename, crypto::hash &hash)
boost::optional< std::pair< uint32_t, uint32_t > >	parse_subaddress_lookahead (const std::string &str)
int	display_simple_progress_spinner (int x)
std::string	glob_to_regex (const std::string &val)
void	closefrom (int fd)
std::string	get_human_readable_timestamp (uint64_t ts)
std::string	get_human_readable_bytes (uint64_t bytes)
template<typename OutputIt , typename T >
std::enable_if< std::is_integral< T >::value &&std::is_unsigned< T >::value, void >::type	write_varint (OutputIt &&dest, T i)
	writes a varint to a stream. More...
template<typename T >
std::string	get_varint_data (const T &v)
	Returns the string that represents the varint. More...

Variables
el::Level	performance_timer_log_level = el::Level::Info
const size_t	MAX_SPLIT_ATTEMPTS = 30

Detailed Description

Various Tools.

Typedef Documentation

download_async_handle

typedef std::shared_ptr<download_thread_control> tools::download_async_handle

Definition at line 37 of file download.h.

ub_result_ptr

typedef class scoped_ptr< ub_result, ub_resolve_free > tools::ub_result_ptr

Definition at line 186 of file dns_utils.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Error codes for varint.

Enumerator
EVARINT_OVERFLOW
EVARINT_REPRESENT

Definition at line 58 of file varint.h.

       {
    /* \brief Represents the overflow error */
    EVARINT_OVERFLOW = -1,
    /* \brief Represents a non conical represnetation */
    EVARINT_REPRESENT = -2,
  };

Function Documentation

apply_permutation() [1/2]

template<typename T >

void tools::apply_permutation	(	const std::vector< size_t > &	permutation,
		std::vector< T > &	v
	)

Definition at line 64 of file apply_permutation.h.

{
  CHECK_AND_ASSERT_THROW_MES(permutation.size() == v.size(), "Mismatched vector sizes");
  apply_permutation(permutation, [&v](size_t i0, size_t i1){ std::swap(v[i0], v[i1]); });
}

Here is the call graph for this function:

apply_permutation() [2/2]

template<typename F >

void tools::apply_permutation	(	std::vector< size_t >	permutation,
		const F &	swap
	)

Definition at line 43 of file apply_permutation.h.

{
  //sanity check
  for (size_t n = 0; n < permutation.size(); ++n)
    CHECK_AND_ASSERT_THROW_MES(std::find(permutation.begin(), permutation.end(), n) != permutation.end(), "Bad permutation");
 
  for (size_t i = 0; i < permutation.size(); ++i)
  {
    size_t current = i;
    while (i != permutation[current])
    {
      size_t next = permutation[current];
      swap(current, next);
      permutation[current] = current;
      current = next;
    }
    permutation[current] = current;
  }
}

Here is the caller graph for this function:

check_updates()

bool tools::check_updates	(	const std::string &	software,
		const std::string &	buildtag,
		std::string &	version,
		std::string &	hash
	)

Definition at line 41 of file updates.cpp.

  {
    std::vector<std::string> records;
    bool found = false;
 
    MDEBUG("Checking updates for " << buildtag << " " << software);
 
    // All four ElectroneumPulse domains have DNSSEC on and valid
    static const std::vector<std::string> dns_urls = {
      "updates.electroneumpulse.com",
      "updates.electroneumpulse.info",
      "updates.electroneumpulse.net",
      "updates.electroneumpulse.org"
    };
 
    if (!tools::dns_utils::load_txt_records_from_dns(records, dns_urls, "update"))
      return false;
 
    for (const auto& record : records)
    {
      std::vector<std::string> fields;
      boost::split(fields, record, boost::is_any_of(":"));
      if (fields.size() != 4)
      {
        MWARNING("Updates record does not have 4 fields: " << record);
        continue;
      }
 
      if (software != fields[0] || buildtag != fields[1])
        continue;
 
      bool alnum = true;
      for (auto c: fields[3])
        if (!isalnum(c))
          alnum = false;
      if (fields[3].size() != 64 && !alnum)
      {
        MWARNING("Invalid hash: " << fields[3]);
        continue;
      }
 
      // use highest version
      if (found)
      {
        int cmp = vercmp(version.c_str(), fields[2].c_str());
        if (cmp > 0)
          continue;
        if (cmp == 0 && hash != fields[3])
          MWARNING("Two matches found for " << software << " version " << version << " on " << buildtag);
      }
 
      version = fields[2];
      hash = fields[3];
 
      MINFO("Found new version " << version << " with hash " << hash);
      found = true;
    }
    return found;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

closefrom()

void tools::closefrom

(

int

fd

)

Definition at line 1058 of file util.cpp.

  {
#if defined __FreeBSD__ || defined __OpenBSD__ || defined __NetBSD__ || defined __DragonFly__
    ::closefrom(fd);
#else
#if defined __GLIBC__
    const int sc_open_max =  sysconf(_SC_OPEN_MAX);
    const int MAX_FDS = std::min(65536, sc_open_max);
#else
    const int MAX_FDS = 65536;
#endif
    while (fd < MAX_FDS)
    {
      close(fd);
      ++fd;
    }
#endif
  }

Here is the caller graph for this function:

combinations_count()

uint64_t tools::combinations_count	(	uint32_t	k,
		uint32_t	n
	)

Definition at line 35 of file combinator.cpp.

{
  if (k > n) {
    throw std::runtime_error("k must not be greater than n");
  }
 
  uint64_t c = 1;
  for (uint64_t i = 1; i <= k; ++i) {
    c *= n--;
    c /= i;
  }
 
  return c;
}

Here is the caller graph for this function:

create_directories_if_necessary()

bool tools::create_directories_if_necessary

(

const std::string &

path

)

creates directories for a path

wrapper around boost::filesyste::create_directories.
(ensure-directory-exists): greenspun's tenth rule in action!

Definition at line 625 of file util.cpp.

  {
    namespace fs = boost::filesystem;
    boost::system::error_code ec;
    fs::path fs_path(path);
    if (fs::is_directory(fs_path, ec))
    {
      return true;
    }
 
    bool res = fs::create_directories(fs_path, ec);
    if (res)
    {
      LOG_PRINT_L2("Created directory: " << path);
    }
    else
    {
      LOG_PRINT_L2("Can't create directory: " << path << ", err: "<< ec.message());
    }
 
    return res;
  }

Here is the caller graph for this function:

disable_core_dumps()

bool tools::disable_core_dumps

(

)

Definition at line 748 of file util.cpp.

  {
#ifdef __GLIBC__
    // disable core dumps in release mode
    struct rlimit rlimit;
    rlimit.rlim_cur = rlimit.rlim_max = 0;
    if (setrlimit(RLIMIT_CORE, &rlimit))
    {
      MWARNING("Failed to disable core dumps");
      return false;
    }
#endif
    return true;
  }

Here is the caller graph for this function:

display_simple_progress_spinner()

int tools::display_simple_progress_spinner

(

int

x

)

Definition at line 995 of file util.cpp.

                                             {
    std::string s;
    x++;
    if (x == 1) {
      s = "|";
    } else if (x == 2) {
      s = "/";
    } else if (x == 3) {
      s = "-";
    } else {
      s = "\\";
      x = 0;
    }
    std::cout << "\r" << s << std::flush;
    return x;
  }

download()

bool tools::download	(	const std::string &	path,
		const std::string &	url,
		std::function< bool(const std::string &, const std::string &, size_t, ssize_t)>	cb
	)

Definition at line 258 of file download.cpp.

  {
    bool success = false;
    download_async_handle handle = download_async(path, url, [&success](const std::string&, const std::string&, bool result) {success = result;}, cb);
    download_wait(handle);
    return success;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

download_async()

download_async_handle tools::download_async	(	const std::string &	path,
		const std::string &	url,
		std::function< void(const std::string &, const std::string &, bool)>	result,
		std::function< bool(const std::string &, const std::string &, size_t, ssize_t)>	progress
	)

Definition at line 266 of file download.cpp.

  {
    download_async_handle control = std::make_shared<download_thread_control>(path, url, result, progress);
    control->thread = boost::thread([control](){ download_thread(control); });
    return control;
  }

Here is the caller graph for this function:

download_cancel()

bool tools::download_cancel

(

const download_async_handle &

control

)

Definition at line 299 of file download.cpp.

  {
    CHECK_AND_ASSERT_MES(control != 0, false, "NULL async download handle");
    {
      boost::lock_guard<boost::mutex> lock(control->mutex);
      if (control->stopped)
        return true;
      control->stop = true;
    }
    control->thread.join();
    return true;
  }

Here is the caller graph for this function:

download_error()

bool tools::download_error

(

const download_async_handle &

control

)

Definition at line 280 of file download.cpp.

  {
    CHECK_AND_ASSERT_MES(control != 0, false, "NULL async download handle");
    boost::lock_guard<boost::mutex> lock(control->mutex);
    return !control->success;
  }

download_finished()

bool tools::download_finished

(

const download_async_handle &

control

)

Definition at line 273 of file download.cpp.

  {
    CHECK_AND_ASSERT_MES(control != 0, false, "NULL async download handle");
    boost::lock_guard<boost::mutex> lock(control->mutex);
    return control->stopped;
  }

download_wait()

bool tools::download_wait

(

const download_async_handle &

control

)

Definition at line 287 of file download.cpp.

  {
    CHECK_AND_ASSERT_MES(control != 0, false, "NULL async download handle");
    {
      boost::lock_guard<boost::mutex> lock(control->mutex);
      if (control->stopped)
        return true;
    }
    control->thread.join();
    return true;
  }

Here is the caller graph for this function:

fail_msg_writer()

scoped_message_writer tools::fail_msg_writer ( )

inline

Definition at line 131 of file scoped_message_writer.h.

{
  return scoped_message_writer(epee::console_color_red, true, "Error: ", el::Level::Error);
}

get_default_data_dir()

std::string tools::get_default_data_dir

(

)

Returns the default data directory.

Windows < Vista: C:\Documents and Settings\Username\Application Data\CRYPTONOTE_NAME

Windows >= Vista: C:\Users\Username\AppData\Roaming\CRYPTONOTE_NAME

Mac: ~/Library/Application Support/CRYPTONOTE_NAME

Unix: ~/.CRYPTONOTE_NAME

Definition at line 600 of file util.cpp.

  {
    /* Please for the love of god refactor  the ifdefs out of this */
 
    // namespace fs = boost::filesystem;
    // Windows < Vista: C:\Documents and Settings\Username\Application Data\CRYPTONOTE_NAME
    // Windows >= Vista: C:\Users\Username\AppData\Roaming\CRYPTONOTE_NAME
    // Unix & Mac: ~/.CRYPTONOTE_NAME
    std::string config_folder;
 
#ifdef WIN32
    config_folder = get_special_folder_path(CSIDL_COMMON_APPDATA, true) + "\\" + CRYPTONOTE_NAME;
#else
    std::string pathRet;
    char* pszHome = getenv("HOME");
    if (pszHome == NULL || strlen(pszHome) == 0)
      pathRet = "/";
    else
      pathRet = pszHome;
    config_folder = (pathRet + "/." + CRYPTONOTE_NAME);
#endif
 
    return config_folder;
  }

Here is the caller graph for this function:

get_human_readable_bytes()

std::string tools::get_human_readable_bytes

(

uint64_t

bytes

)

Definition at line 1089 of file util.cpp.

  {
    // Use 1024 for "kilo", 1024*1024 for "mega" and so on instead of the more modern and standard-conforming
    // 1000, 1000*1000 and so on, to be consistent with other Electroneum code that also uses base 2 units
    struct byte_map
    {
        const char* const format;
        const std::uint64_t bytes;
    };
 
    static constexpr const byte_map sizes[] =
    {
        {"%.0f B", 1024},
        {"%.2f KB", 1024 * 1024},
        {"%.2f MB", std::uint64_t(1024) * 1024 * 1024},
        {"%.2f GB", std::uint64_t(1024) * 1024 * 1024 * 1024},
        {"%.2f TB", std::uint64_t(1024) * 1024 * 1024 * 1024 * 1024}
    };
 
    struct bytes_less
    {
        bool operator()(const byte_map& lhs, const byte_map& rhs) const noexcept
        {
            return lhs.bytes < rhs.bytes;
        }
    };
 
    const auto size = std::upper_bound(
        std::begin(sizes), std::end(sizes) - 1, byte_map{"", bytes}, bytes_less{}
    );
    const std::uint64_t divisor = size->bytes / 1024;
    return (boost::format(size->format) % (double(bytes) / divisor)).str();
  }

Here is the caller graph for this function:

get_human_readable_timestamp()

std::string tools::get_human_readable_timestamp

(

uint64_t

ts

)

Definition at line 1077 of file util.cpp.

  {
    char buffer[64];
    if (ts < 1234567890)
      return "<unknown>";
    time_t tt = ts;
    struct tm tm;
    misc_utils::get_gmt_time(tt, tm);
    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm);
    return std::string(buffer);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_lockable_memory()

ssize_t tools::get_lockable_memory

(

)

Definition at line 763 of file util.cpp.

  {
#ifdef __GLIBC__
    struct rlimit rlim;
    if (getrlimit(RLIMIT_MEMLOCK, &rlim) < 0)
    {
      MERROR("Failed to determine the lockable memory limit");
      return -1;
    }
    return rlim.rlim_cur;
#else
    return -1;
#endif
  }

Here is the caller graph for this function:

get_max_concurrency()

unsigned tools::get_max_concurrency

(

)

Definition at line 868 of file util.cpp.

  {
    boost::lock_guard<boost::mutex> lock(max_concurrency_lock);
    return max_concurrency;
  }

get_next_pruned_block_height()

uint64_t tools::get_next_pruned_block_height	(	uint64_t	block_height,
		uint64_t	blockchain_height,
		uint32_t	pruning_seed
	)

Definition at line 93 of file pruning.cpp.

{
  const uint32_t stripe = get_pruning_stripe(pruning_seed);
  if (stripe == 0)
    return blockchain_height;
  if (block_height + CRYPTONOTE_PRUNING_TIP_BLOCKS >= blockchain_height)
    return blockchain_height;
  const uint32_t seed_log_stripes = get_pruning_log_stripes(pruning_seed);
  const uint64_t log_stripes = seed_log_stripes ? seed_log_stripes : CRYPTONOTE_PRUNING_LOG_STRIPES;
  const uint64_t mask = (1ul << log_stripes) - 1;
  const uint32_t block_pruning_seed = ((block_height / CRYPTONOTE_PRUNING_STRIPE_SIZE) & mask) + 1;
  if (block_pruning_seed != stripe)
    return block_height;
  const uint32_t next_stripe = 1 + (block_pruning_seed & mask);
  return get_next_unpruned_block_height(block_height, blockchain_height, tools::make_pruning_seed(next_stripe, log_stripes));
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_next_unpruned_block_height()

uint64_t tools::get_next_unpruned_block_height	(	uint64_t	block_height,
		uint64_t	blockchain_height,
		uint32_t	pruning_seed
	)

Definition at line 69 of file pruning.cpp.

{
  CHECK_AND_ASSERT_MES(block_height <= CRYPTONOTE_MAX_BLOCK_NUMBER+1, block_height, "block_height too large");
  CHECK_AND_ASSERT_MES(blockchain_height <= CRYPTONOTE_MAX_BLOCK_NUMBER+1, block_height, "blockchain_height too large");
  const uint32_t stripe = get_pruning_stripe(pruning_seed);
  if (stripe == 0)
    return block_height;
  if (block_height + CRYPTONOTE_PRUNING_TIP_BLOCKS >= blockchain_height)
    return block_height;
  const uint32_t seed_log_stripes = get_pruning_log_stripes(pruning_seed);
  const uint64_t log_stripes = seed_log_stripes ? seed_log_stripes : CRYPTONOTE_PRUNING_LOG_STRIPES;
  const uint64_t mask = (1ul << log_stripes) - 1;
  const uint32_t block_pruning_stripe = ((block_height / CRYPTONOTE_PRUNING_STRIPE_SIZE) & mask) + 1;
  if (block_pruning_stripe == stripe)
    return block_height;
  const uint64_t cycles = ((block_height / CRYPTONOTE_PRUNING_STRIPE_SIZE) >> log_stripes);
  const uint64_t cycle_start = cycles + ((stripe > block_pruning_stripe) ? 0 : 1);
  const uint64_t h = cycle_start * (CRYPTONOTE_PRUNING_STRIPE_SIZE << log_stripes) + (stripe - 1) * CRYPTONOTE_PRUNING_STRIPE_SIZE;
  if (h + CRYPTONOTE_PRUNING_TIP_BLOCKS > blockchain_height)
    return blockchain_height < CRYPTONOTE_PRUNING_TIP_BLOCKS ? 0 : blockchain_height - CRYPTONOTE_PRUNING_TIP_BLOCKS;
  CHECK_AND_ASSERT_MES(h >= block_height, block_height, "h < block_height, unexpected");
  return h;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_nix_version_display_string()

std::string tools::get_nix_version_display_string

(

)

Definition at line 554 of file util.cpp.

{
  struct utsname un;
 
  if(uname(&un) < 0)
    return std::string("*nix: failed to get os version");
  return std::string() + un.sysname + " " + un.version + " " + un.release;
}

Here is the caller graph for this function:

get_os_version_string()

std::string tools::get_os_version_string

(

)

Returns the OS version string.

This is a wrapper around the primitives get_windows_version_display_string() and get_nix_version_display_string()

Definition at line 566 of file util.cpp.

  {
#ifdef WIN32
    return get_windows_version_display_string();
#else
    return get_nix_version_display_string();
#endif
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_pruning_log_stripes()

constexpr uint32_t tools::get_pruning_log_stripes ( uint32_t  pruning_seed )

inlineconstexpr

Definition at line 40 of file pruning.h.

{ return (pruning_seed >> PRUNING_SEED_LOG_STRIPES_SHIFT) & PRUNING_SEED_LOG_STRIPES_MASK; }

Here is the caller graph for this function:

get_pruning_seed()

uint32_t tools::get_pruning_seed	(	uint64_t	block_height,
		uint64_t	blockchain_height,
		uint32_t	log_stripes
	)

Definition at line 61 of file pruning.cpp.

{
  const uint32_t stripe = get_pruning_stripe(block_height, blockchain_height, log_stripes);
  if (stripe == 0)
    return 0;
  return make_pruning_seed(stripe, log_stripes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_pruning_stripe() [1/2]

uint32_t tools::get_pruning_stripe ( uint32_t  pruning_seed )

inline

Definition at line 41 of file pruning.h.

{ if (pruning_seed == 0) return 0; return 1 + ((pruning_seed >> PRUNING_SEED_STRIPE_SHIFT) & PRUNING_SEED_STRIPE_MASK); }

get_pruning_stripe() [2/2]

uint32_t tools::get_pruning_stripe	(	uint64_t	block_height,
		uint64_t	blockchain_height,
		uint32_t	log_stripes
	)

Definition at line 54 of file pruning.cpp.

{
  if (block_height + CRYPTONOTE_PRUNING_TIP_BLOCKS >= blockchain_height)
    return 0;
  return ((block_height / CRYPTONOTE_PRUNING_STRIPE_SIZE) & (uint64_t)((1ul << log_stripes) - 1)) + 1;
}

Here is the caller graph for this function:

get_random_stripe()

uint32_t tools::get_random_stripe

(

)

Definition at line 110 of file pruning.cpp.

{
  return 1 + crypto::rand<uint8_t>() % (1ul << CRYPTONOTE_PRUNING_LOG_STRIPES);
}

get_tick_count()

uint64_t tools::get_tick_count

(

)

Definition at line 46 of file perf_timer.cpp.

  {
#if defined(__x86_64__)
    uint32_t hi, lo;
    __asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
    return (((uint64_t)hi) << 32) | (uint64_t)lo;
#else
    return epee::misc_utils::get_ns_count();
#endif
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_ticks_per_ns()

uint64_t tools::get_ticks_per_ns

(

)

get_update_url()

std::string tools::get_update_url	(	const std::string &	software,
		const std::string &	subdir,
		const std::string &	buildtag,
		const std::string &	version,
		bool	user
	)

Definition at line 101 of file updates.cpp.

  {
    const char *base = user ? "http://s3-eu-west-1.amazonaws.com/updates.electroneum.com/releases/download/v" : "http://s3-eu-west-1.amazonaws.com/updates.electroneum.com/releases/download/v";
#ifdef _WIN32
    static const char *extension = strncmp(buildtag.c_str(), "install-", 8) ? ".zip" : ".exe";
#else
    static const char extension[] = ".tar.bz2";
#endif
 
    std::string url;
 
    url =  base;
//    if (!subdir.empty())
//      url += subdir + "/";
    url = url + version + "/" + software + "-" + buildtag + "-v" + version + extension;
    return url;
  }

Here is the caller graph for this function:

get_varint_data()

template<typename T >

std::string tools::get_varint_data

(

const T &

v

)

Returns the string that represents the varint.

Definition at line 85 of file varint.h.

    {
      std::stringstream ss;
      write_varint(std::ostreambuf_iterator<char>(ss), v);
      return ss.str();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

glob_to_regex()

std::string tools::glob_to_regex

(

const std::string &

val

)

Definition at line 1012 of file util.cpp.

  {
    std::string newval;
 
    bool escape = false;
    for (char c: val)
    {
      if (c == '*')
        newval += escape ? "*" : ".*";
      else if (c == '?')
        newval += escape ? "?" : ".";
      else if (c == '\\')
        newval += '\\', escape = !escape;
      else
        newval += c;
    }
    return newval;
  }

Here is the caller graph for this function:

has_unpruned_block()

bool tools::has_unpruned_block	(	uint64_t	block_height,
		uint64_t	blockchain_height,
		uint32_t	pruning_seed
	)

Definition at line 44 of file pruning.cpp.

{
  const uint32_t stripe = get_pruning_stripe(pruning_seed);
  if (stripe == 0)
    return true;
  const uint32_t log_stripes = get_pruning_log_stripes(pruning_seed);
  uint32_t block_stripe = get_pruning_stripe(block_height, blockchain_height, log_stripes);
  return block_stripe == 0 || block_stripe == stripe;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ipv4_to_string()

boost::optional<std::string> tools::ipv4_to_string	(	const char *	src,
		size_t	len
	)

Definition at line 136 of file dns_utils.cpp.

{
  if (len < 4)
  {
    MERROR("Invalid IPv4 address: " << std::string(src, len));
    return boost::none;
  }
 
  std::stringstream ss;
  unsigned int bytes[4];
  for (int i = 0; i < 4; i++)
  {
    unsigned char a = src[i];
    bytes[i] = a;
  }
  ss << bytes[0] << "."
     << bytes[1] << "."
     << bytes[2] << "."
     << bytes[3];
  return ss.str();
}

Here is the caller graph for this function:

ipv6_to_string()

boost::optional<std::string> tools::ipv6_to_string	(	const char *	src,
		size_t	len
	)

Definition at line 160 of file dns_utils.cpp.

{
  if (len < 8)
  {
    MERROR("Invalid IPv4 address: " << std::string(src, len));
    return boost::none;
  }
 
  std::stringstream ss;
  unsigned int bytes[8];
  for (int i = 0; i < 8; i++)
  {
    unsigned char a = src[i];
    bytes[i] = a;
  }
  ss << bytes[0] << ":"
     << bytes[1] << ":"
     << bytes[2] << ":"
     << bytes[3] << ":"
     << bytes[4] << ":"
     << bytes[5] << ":"
     << bytes[6] << ":"
     << bytes[7];
  return ss.str();
}

Here is the caller graph for this function:

is_hdd()

boost::optional< bool > tools::is_hdd

(

const char *

file_path

)

Definition at line 813 of file util.cpp.

  {
#ifdef __GLIBC__
    struct stat st;
    std::string prefix;
    if(stat(file_path, &st) == 0)
    {
      std::ostringstream s;
      s << "/sys/dev/block/" << major(st.st_dev) << ":" << minor(st.st_dev);
      prefix = s.str();
    }
    else
    {
      return boost::none;
    }
    std::string attr_path = prefix + "/queue/rotational";
    std::ifstream f(attr_path, std::ios_base::in);
    if(not f.is_open())
    {
      attr_path = prefix + "/../queue/rotational";
      f.open(attr_path, std::ios_base::in);
      if(not f.is_open())
      {
          return boost::none;
      }
    }
    unsigned short val = 0xdead;
    f >> val;
    if(not f.fail())
    {
      return (val == 1);
    }
    return boost::none;
#else
    return boost::none;
#endif
  }

Here is the caller graph for this function:

is_local_address()

bool tools::is_local_address

(

const std::string &

address

)

Definition at line 874 of file util.cpp.

  {
    // always assume Tor/I2P addresses to be untrusted by default
    if (boost::ends_with(address, ".onion") || boost::ends_with(address, ".i2p"))
    {
      MDEBUG("Address '" << address << "' is Tor/I2P, non local");
      return false;
    }
 
    // extract host
    epee::net_utils::http::url_content u_c;
    if (!epee::net_utils::parse_url(address, u_c))
    {
      MWARNING("Failed to determine whether address '" << address << "' is local, assuming not");
      return false;
    }
    if (u_c.host.empty())
    {
      MWARNING("Failed to determine whether address '" << address << "' is local, assuming not");
      return false;
    }
 
    // resolve to IP
    boost::asio::io_service io_service;
    boost::asio::ip::tcp::resolver resolver(io_service);
    boost::asio::ip::tcp::resolver::query query(u_c.host, "");
    boost::asio::ip::tcp::resolver::iterator i = resolver.resolve(query);
    while (i != boost::asio::ip::tcp::resolver::iterator())
    {
      const boost::asio::ip::tcp::endpoint &ep = *i;
      if (ep.address().is_loopback())
      {
        MDEBUG("Address '" << address << "' is local");
        return true;
      }
      ++i;
    }
 
    MDEBUG("Address '" << address << "' is not local");
    return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

log_stack_trace()

void tools::log_stack_trace

(

const char *

msg

)

Definition at line 121 of file stack_trace.cpp.

{
#ifdef USE_UNWIND
  unw_context_t ctx;
  unw_cursor_t cur;
  unw_word_t ip, off;
  unsigned level;
  char sym[512], *dsym;
  int status;
  const char *log = stack_trace_log.empty() ? NULL : stack_trace_log.c_str();
#endif
 
  if (msg)
    ST_LOG(msg);
  ST_LOG("Unwound call stack:");
 
#ifdef USE_UNWIND
  if (unw_getcontext(&ctx) < 0) {
    ST_LOG("Failed to create unwind context");
    return;
  }
  if (unw_init_local(&cur, &ctx) < 0) {
    ST_LOG("Failed to find the first unwind frame");
    return;
  }
  for (level = 1; level < 999; ++level) { // 999 for safety
    int ret = unw_step(&cur);
    if (ret < 0) {
      ST_LOG("Failed to find the next frame");
      return;
    }
    if (ret == 0)
      break;
    if (unw_get_reg(&cur, UNW_REG_IP, &ip) < 0) {
      ST_LOG("  " << std::setw(4) << level);
      continue;
    }
    if (unw_get_proc_name(&cur, sym, sizeof(sym), &off) < 0) {
      ST_LOG("  " << std::setw(4) << level << std::setbase(16) << std::setw(20) << "0x" << ip);
      continue;
    }
    dsym = abi::__cxa_demangle(sym, NULL, NULL, &status);
    ST_LOG("  " << std::setw(4) << level << std::setbase(16) << std::setw(20) << "0x" << ip << " " << (!status && dsym ? dsym : sym) << " + " << "0x" << off);
    free(dsym);
  }
#else
  std::stringstream ss;
  ss << el::base::debug::StackTrace();
  std::vector<std::string> lines;
  std::string s = ss.str();
  boost::split(lines, s, boost::is_any_of("\n"));
  for (const auto &line: lines)
    ST_LOG(line);
#endif
}

make_pruning_seed()

uint32_t tools::make_pruning_seed	(	uint32_t	stripe,
		uint32_t	log_stripes
	)

Definition at line 37 of file pruning.cpp.

{
  CHECK_AND_ASSERT_THROW_MES(log_stripes <= PRUNING_SEED_LOG_STRIPES_MASK, "log_stripes out of range");
  CHECK_AND_ASSERT_THROW_MES(stripe > 0 && stripe <= (1ul << log_stripes), "stripe out of range");
  return (log_stripes << PRUNING_SEED_LOG_STRIPES_SHIFT) | ((stripe - 1) << PRUNING_SEED_STRIPE_SHIFT);
}

Here is the caller graph for this function:

msg_writer()

scoped_message_writer tools::msg_writer ( epee::console_colors  color = epee::console_color_default )

inline

Definition at line 126 of file scoped_message_writer.h.

{
  return scoped_message_writer(color, false, std::string(), el::Level::Info);
}

Here is the caller graph for this function:

on_startup()

bool tools::on_startup

(

)

Definition at line 778 of file util.cpp.

  {
    mlog_configure("", true);
 
    setup_crash_dump();
 
    sanitize_locale();
 
#ifdef __GLIBC__
    const char *ver = gnu_get_libc_version();
    if (!strcmp(ver, "2.25"))
      MCLOG_RED(el::Level::Warning, "global", "Running with glibc " << ver << ", hangs may occur - change glibc version if possible");
#endif
 
#if OPENSSL_VERSION_NUMBER < 0x10100000 || defined(LIBRESSL_VERSION_TEXT)
    SSL_library_init();
#else
    OPENSSL_init_ssl(0, NULL);
#endif
 
    if (!unbound_built_with_threads())
      MCLOG_RED(el::Level::Warning, "global", "libunbound was not built with threads enabled - crashes may occur");
 
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

parse_subaddress_lookahead()

boost::optional< std::pair< uint32_t, uint32_t > > tools::parse_subaddress_lookahead

(

const std::string &

str

)

Definition at line 977 of file util.cpp.

  {
    auto pos = str.find(":");
    bool r = pos != std::string::npos;
    uint32_t major;
    r = r && epee::string_tools::get_xtype_from_string(major, str.substr(0, pos));
    uint32_t minor;
    r = r && epee::string_tools::get_xtype_from_string(minor, str.substr(pos + 1));
    if (r)
    {
      return std::make_pair(major, minor);
    }
    else
    {
      return {};
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

replace_file()

std::error_code tools::replace_file	(	const std::string &	old_name,
		const std::string &	new_name
	)

std::rename wrapper for nix and something strange for windows.

Definition at line 648 of file util.cpp.

  {
    int code;
#if defined(WIN32)
    // Maximizing chances for success
    std::wstring wide_replacement_name;
    try { wide_replacement_name = string_tools::utf8_to_utf16(old_name); }
    catch (...) { return std::error_code(GetLastError(), std::system_category()); }
    std::wstring wide_replaced_name;
    try { wide_replaced_name = string_tools::utf8_to_utf16(new_name); }
    catch (...) { return std::error_code(GetLastError(), std::system_category()); }
 
    DWORD attributes = ::GetFileAttributesW(wide_replaced_name.c_str());
    if (INVALID_FILE_ATTRIBUTES != attributes)
    {
      ::SetFileAttributesW(wide_replaced_name.c_str(), attributes & (~FILE_ATTRIBUTE_READONLY));
    }
 
    bool ok = 0 != ::MoveFileExW(wide_replacement_name.c_str(), wide_replaced_name.c_str(), MOVEFILE_REPLACE_EXISTING);
    code = ok ? 0 : static_cast<int>(::GetLastError());
#else
    bool ok = 0 == std::rename(old_name.c_str(), new_name.c_str());
    code = ok ? 0 : errno;
#endif
    return std::error_code(code, std::system_category());
  }

Here is the caller graph for this function:

sanitize_locale()

bool tools::sanitize_locale

(

)

Definition at line 690 of file util.cpp.

  {
    // boost::filesystem throws for "invalid" locales, such as en_US.UTF-8, or kjsdkfs,
    // so reset it here before any calls to it
    try
    {
      boost::filesystem::path p {std::string("test")};
      p /= std::string("test");
    }
    catch (...)
    {
#if defined(__MINGW32__) || defined(__MINGW__)
      putenv("LC_ALL=C");
      putenv("LANG=C");
#else
      setenv("LC_ALL", "C", 1);
      setenv("LANG", "C", 1);
#endif
      return true;
    }
    return false;
  }

serialize_obj_to_file()

template<class t_object >

bool tools::serialize_obj_to_file	(	t_object &	obj,
		const std::string &	file_path
	)

Definition at line 43 of file boost_serialization_helper.h.

  {
    TRY_ENTRY();
#if defined(_MSC_VER)
    // Need to know HANDLE of file to call FlushFileBuffers
    HANDLE data_file_handle = ::CreateFile(file_path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (INVALID_HANDLE_VALUE == data_file_handle)
      return false;
 
    int data_file_descriptor = _open_osfhandle((intptr_t)data_file_handle, 0);
    if (-1 == data_file_descriptor)
    {
      ::CloseHandle(data_file_handle);
      return false;
    }
 
    const std::unique_ptr<FILE, tools::close_file> data_file_file{_fdopen(data_file_descriptor, "wb")};
    if (nullptr == data_file_file)
    {
      // Call CloseHandle is not necessary
      _close(data_file_descriptor);
      return false;
    }
 
    // HACK: undocumented constructor, this code may not compile
    std::ofstream data_file(data_file_file.get());
    if (data_file.fail())
    {
      // Call CloseHandle and _close are not necessary
      return false;
    }
#else
    std::ofstream data_file;
    data_file.open(file_path , std::ios_base::binary | std::ios_base::out| std::ios::trunc);
    if (data_file.fail())
      return false;
#endif
 
    boost::archive::portable_binary_oarchive a(data_file);
    a << obj;
    if (data_file.fail())
      return false;
 
    data_file.flush();
#if defined(_MSC_VER)
    // To make sure the file is fully stored on disk
    ::FlushFileBuffers(data_file_handle);
#endif
 
    return true;
    CATCH_ENTRY_L0("serialize_obj_to_file", false);
  }

set_max_concurrency()

void tools::set_max_concurrency

(

unsigned

n

)

Definition at line 857 of file util.cpp.

  {
    if (n < 1)
      n = boost::thread::hardware_concurrency();
    unsigned hwc = boost::thread::hardware_concurrency();
    if (n > hwc)
      n = hwc;
    boost::lock_guard<boost::mutex> lock(max_concurrency_lock);
    max_concurrency = n;
  }

Here is the caller graph for this function:

set_performance_timer_log_level()

void tools::set_performance_timer_log_level

(

el::Level

level

)

Definition at line 96 of file perf_timer.cpp.

{
  if (level != el::Level::Debug && level != el::Level::Trace && level != el::Level::Info
   && level != el::Level::Warning && level != el::Level::Error && level != el::Level::Fatal)
  {
    MERROR("Wrong log level: " << el::LevelHelper::convertToString(level) << ", using Info");
    level = el::Level::Info;
  }
  performance_timer_log_level = level;
}

Here is the call graph for this function:

set_stack_trace_log()

void tools::set_stack_trace_log

(

const std::string &

log

)

Definition at line 116 of file stack_trace.cpp.

{
  stack_trace_log = log;
}

Here is the caller graph for this function:

set_strict_default_file_permissions()

void tools::set_strict_default_file_permissions

(

bool

strict

)

Definition at line 803 of file util.cpp.

  {
#if defined(__MINGW32__) || defined(__MINGW__)
    // no clue about the odd one out
#else
    mode_t mode = strict ? 077 : 0;
    umask(mode);
#endif
  }

Here is the caller graph for this function:

sha256sum() [1/2]

bool tools::sha256sum	(	const std::string &	filename,
		crypto::hash &	hash
	)

Definition at line 945 of file util.cpp.

  {
    if (!epee::file_io_utils::is_file_exist(filename))
      return false;
    std::ifstream f;
    f.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    f.open(filename, std::ios_base::binary | std::ios_base::in | std::ios::ate);
    if (!f)
      return false;
    std::ifstream::pos_type file_size = f.tellg();
    SHA256_CTX ctx;
    if (!SHA256_Init(&ctx))
      return false;
    size_t size_left = file_size;
    f.seekg(0, std::ios::beg);
    while (size_left)
    {
      char buf[4096];
      std::ifstream::pos_type read_size = size_left > sizeof(buf) ? sizeof(buf) : size_left;
      f.read(buf, read_size);
      if (!f || !f.good())
        return false;
      if (!SHA256_Update(&ctx, buf, read_size))
        return false;
      size_left -= read_size;
    }
    f.close();
    if (!SHA256_Final((unsigned char*)hash.data, &ctx))
      return false;
    return true;
  }

Here is the call graph for this function:

sha256sum() [2/2]

bool tools::sha256sum	(	const uint8_t *	data,
		size_t	len,
		crypto::hash &	hash
	)

Definition at line 933 of file util.cpp.

  {
    SHA256_CTX ctx;
    if (!SHA256_Init(&ctx))
      return false;
    if (!SHA256_Update(&ctx, data, len))
      return false;
    if (!SHA256_Final((unsigned char*)hash.data, &ctx))
      return false;
    return true;
  }

Here is the caller graph for this function:

spawn()

int tools::spawn	(	const char *	filename,
		const std::vector< std::string > &	args,
		bool	wait
	)

Definition at line 51 of file spawn.cpp.

{
#ifdef _WIN32
  std::string joined = boost::algorithm::join(args, " ");
  char *commandLine = !joined.empty() ? &joined[0] : nullptr;
  STARTUPINFOA si = {};
  si.cb = sizeof(si);
  PROCESS_INFORMATION pi;
  if (!CreateProcessA(filename, commandLine, nullptr, nullptr, false, 0, nullptr, nullptr, &si, &pi))
  {
    MERROR("CreateProcess failed. Error code " << GetLastError());
    return -1;
  }
  
  BOOST_SCOPE_EXIT(&pi)
  {
    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);
  }
  BOOST_SCOPE_EXIT_END
 
  if (!wait)
  {
    return 0;
  }
 
  DWORD result = WaitForSingleObject(pi.hProcess, INFINITE);
  if (result != WAIT_OBJECT_0)
  {
    MERROR("WaitForSingleObject failed. Result " << result << ", error code " << GetLastError());
    return -1;
  }
 
  DWORD exitCode;
  if (!GetExitCodeProcess(pi.hProcess, &exitCode))
  {
    MERROR("GetExitCodeProcess failed. Error code " << GetLastError());
    return -1;
  }
 
  MINFO("Child exited with " << exitCode);
  return static_cast<int>(exitCode);
#else
  std::vector<char*> argv(args.size() + 1);
  for (size_t n = 0; n < args.size(); ++n)
    argv[n] = (char*)args[n].c_str();
  argv[args.size()] = NULL;
 
  pid_t pid = fork();
  if (pid < 0)
  {
    MERROR("Error forking: " << strerror(errno));
    return -1;
  }
 
  // child
  if (pid == 0)
  {
    tools::closefrom(3);
    close(0);
    char *envp[] = {NULL};
    execve(filename, argv.data(), envp);
    MERROR("Failed to execve: " << strerror(errno));
    return -1;
  }
 
  // parent
  if (pid > 0)
  {
    if (!wait)
    {
      signal(SIGCHLD, SIG_IGN);
      return 0;
    }
 
    while (1)
    {
      int wstatus = 0;
      pid_t w = waitpid(pid, &wstatus, WUNTRACED | WCONTINUED);
      if (w  < 0) {
        MERROR("Error waiting for child: " << strerror(errno));
        return -1;
      }
      if (WIFEXITED(wstatus))
      {
        MINFO("Child exited with " << WEXITSTATUS(wstatus));
        return WEXITSTATUS(wstatus);
      }
      if (WIFSIGNALED(wstatus))
      {
        MINFO("Child killed by " << WEXITSTATUS(wstatus));
        return WEXITSTATUS(wstatus);
      }
    }
  }
  MERROR("Secret passage found");
  return -1;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

success_msg_writer()

scoped_message_writer tools::success_msg_writer ( bool  color = true )

inline

Definition at line 121 of file scoped_message_writer.h.

{
  return scoped_message_writer(color ? epee::console_color_green : epee::console_color_default, false, std::string(), el::Level::Info);
}

Here is the caller graph for this function:

ticks_to_ns()

uint64_t tools::ticks_to_ns

(

uint64_t

ticks

)

Definition at line 79 of file perf_timer.cpp.

  {
#if defined(__x86_64__)
    return 256 * ticks / ticks_per_ns;
#else
    return ticks;
#endif
  }

Here is the caller graph for this function:

txt_to_string()

boost::optional<std::string> tools::txt_to_string	(	const char *	src,
		size_t	len
	)

Definition at line 186 of file dns_utils.cpp.

{
  if (len == 0)
    return boost::none;
  return std::string(src+1, len-1);
}

Here is the caller graph for this function:

unserialize_obj_from_file()

template<class t_object >

bool tools::unserialize_obj_from_file	(	t_object &	obj,
		const std::string &	file_path
	)

Definition at line 97 of file boost_serialization_helper.h.

  {
    TRY_ENTRY();
 
    std::ifstream data_file;  
    data_file.open( file_path, std::ios_base::binary | std::ios_base::in);
    if(data_file.fail())
      return false;
    try
    {
      // first try reading in portable mode
      boost::archive::portable_binary_iarchive a(data_file);
      a >> obj;
    }
    catch(...)
    {
      // if failed, try reading in unportable mode
      boost::filesystem::copy_file(file_path, file_path + ".unportable", boost::filesystem::copy_option::overwrite_if_exists);
      data_file.close();
      data_file.open( file_path, std::ios_base::binary | std::ios_base::in);
      if(data_file.fail())
        return false;
      boost::archive::binary_iarchive a(data_file);
      a >> obj;
    }
    return !data_file.fail();
    CATCH_ENTRY_L0("unserialize_obj_from_file", false);
  }

Here is the caller graph for this function:

vercmp()

int tools::vercmp	(	const char *	v0,
		const char *	v1
	)

Definition at line 915 of file util.cpp.

  {
    std::vector<std::string> f0, f1;
    boost::split(f0, v0, boost::is_any_of(".-"));
    boost::split(f1, v1, boost::is_any_of(".-"));
    for (size_t i = 0; i < std::max(f0.size(), f1.size()); ++i) {
      if (i >= f0.size())
        return -1;
      if (i >= f1.size())
        return 1;
      int f0i = atoi(f0[i].c_str()), f1i = atoi(f1[i].c_str());
      int n = f0i - f1i;
      if (n)
        return n;
    }
    return 0;
  }

Here is the caller graph for this function:

write_varint()

template<typename OutputIt , typename T >

std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, void>::type tools::write_varint	(	OutputIt &&	dest,
		T	i
	)

writes a varint to a stream.

Definition at line 70 of file varint.h.

                                     {
    /* Make sure that there is one after this */
    while (i >= 0x80) {
      *dest = (static_cast<char>(i) & 0x7f) | 0x80; 
      ++dest;
      i >>= 7;          /* I should be in multiples of 7, this should just get the next part */
    }
    /* writes the last one to dest */
    *dest = static_cast<char>(i);
    dest++;         /* Seems kinda pointless... */
  }

Here is the caller graph for this function:

Variable Documentation

MAX_SPLIT_ATTEMPTS

const size_t tools::MAX_SPLIT_ATTEMPTS = 30

Definition at line 990 of file wallet2.cpp.

performance_timer_log_level

el::Level tools::performance_timer_log_level = el::Level::Info

Definition at line 92 of file perf_timer.cpp.