nodetool::peerlist_manager Class Reference

#include <net_peerlist.h>

Public Member Functions
bool	init (peerlist_types &&peers, bool allow_local_ip)
size_t	get_white_peers_count ()
size_t	get_gray_peers_count ()
bool	merge_peerlist (const std::vector< peerlist_entry > &outer_bs)
bool	get_peerlist_head (std::vector< peerlist_entry > &bs_head, bool anonymize, uint32_t depth=P2P_DEFAULT_PEERS_IN_HANDSHAKE)
void	get_peerlist (std::vector< peerlist_entry > &pl_gray, std::vector< peerlist_entry > &pl_white)
void	get_peerlist (peerlist_types &peers)
bool	get_white_peer_by_index (peerlist_entry &p, size_t i)
bool	get_gray_peer_by_index (peerlist_entry &p, size_t i)
template<typename F>
bool	foreach (bool white, const F &f)
bool	append_with_peer_white (const peerlist_entry &pr)
bool	append_with_peer_gray (const peerlist_entry &pr)
bool	append_with_peer_anchor (const anchor_peerlist_entry &ple)
bool	set_peer_just_seen (peerid_type peer, const epee::net_utils::network_address &addr, uint32_t pruning_seed, uint16_t rpc_port)
bool	set_peer_unreachable (const peerlist_entry &pr)
bool	is_host_allowed (const epee::net_utils::network_address &address)
bool	get_random_gray_peer (peerlist_entry &pe)
bool	remove_from_peer_gray (const peerlist_entry &pe)
bool	get_and_empty_anchor_peerlist (std::vector< anchor_peerlist_entry > &apl)
bool	remove_from_peer_anchor (const epee::net_utils::network_address &addr)
bool	remove_from_peer_white (const peerlist_entry &pe)

Friends
class	boost::serialization::access

Detailed Description

Definition at line 99 of file net_peerlist.h.

Member Function Documentation

append_with_peer_anchor()

bool nodetool::peerlist_manager::append_with_peer_anchor ( const anchor_peerlist_entry & ple )

inline

Definition at line 403 of file net_peerlist.h.

  {
    TRY_ENTRY();
 
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
 
    auto by_addr_it_anchor = m_peers_anchor.get<by_addr>().find(ple.adr);
 
    if(by_addr_it_anchor == m_peers_anchor.get<by_addr>().end()) {
      m_peers_anchor.insert(ple);
    }
 
    return true;
 
    CATCH_ENTRY_L0("peerlist_manager::append_with_peer_anchor()", false);
  }

append_with_peer_gray()

bool nodetool::peerlist_manager::append_with_peer_gray ( const peerlist_entry & pr )

inline

Definition at line 368 of file net_peerlist.h.

  {
    TRY_ENTRY();
    if(!is_host_allowed(ple.adr))
      return true;
 
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    //find in white list
    auto by_addr_it_wt = m_peers_white.get<by_addr>().find(ple.adr);
    if(by_addr_it_wt != m_peers_white.get<by_addr>().end())
      return true;
 
    //update gray list
    auto by_addr_it_gr = m_peers_gray.get<by_addr>().find(ple.adr);
    if(by_addr_it_gr == m_peers_gray.get<by_addr>().end())
    {
      //put new record into white list
      m_peers_gray.insert(ple);
      trim_gray_peerlist();    
    }else
    {
      //update record in gray list
      peerlist_entry new_ple = ple;
      if (by_addr_it_gr->pruning_seed && ple.pruning_seed == 0) // guard against older nodes not passing pruning info around
        new_ple.pruning_seed = by_addr_it_gr->pruning_seed;
      if (by_addr_it_gr->rpc_port && ple.rpc_port == 0) // guard against older nodes not passing RPC port around
        new_ple.rpc_port = by_addr_it_gr->rpc_port;
      new_ple.last_seen = by_addr_it_gr->last_seen; // do not overwrite the last seen timestamp, incoming peer list are untrusted
      m_peers_gray.replace(by_addr_it_gr, new_ple);
    }
    return true;
    CATCH_ENTRY_L0("peerlist_manager::append_with_peer_gray()", false);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

append_with_peer_white()

bool nodetool::peerlist_manager::append_with_peer_white ( const peerlist_entry & pr )

inline

Definition at line 332 of file net_peerlist.h.

  {
    TRY_ENTRY();
    if(!is_host_allowed(ple.adr))
      return true;
 
     CRITICAL_REGION_LOCAL(m_peerlist_lock);
    //find in white list
    auto by_addr_it_wt = m_peers_white.get<by_addr>().find(ple.adr);
    if(by_addr_it_wt == m_peers_white.get<by_addr>().end())
    {
      //put new record into white list
      m_peers_white.insert(ple);
      trim_white_peerlist();
    }else
    {
      //update record in white list
      peerlist_entry new_ple = ple;
      if (by_addr_it_wt->pruning_seed && ple.pruning_seed == 0) // guard against older nodes not passing pruning info around
        new_ple.pruning_seed = by_addr_it_wt->pruning_seed;
      if (by_addr_it_wt->rpc_port && ple.rpc_port == 0) // guard against older nodes not passing RPC port around
        new_ple.rpc_port = by_addr_it_wt->rpc_port;
      new_ple.last_seen = by_addr_it_wt->last_seen; // do not overwrite the last seen timestamp, incoming peer list are untrusted
      m_peers_white.replace(by_addr_it_wt, new_ple);
    }
    //remove from gray list, if need
    auto by_addr_it_gr = m_peers_gray.get<by_addr>().find(ple.adr);
    if(by_addr_it_gr != m_peers_gray.get<by_addr>().end())
    {
      m_peers_gray.erase(by_addr_it_gr);
    }
    return true;
    CATCH_ENTRY_L0("peerlist_manager::append_with_peer_white()", false);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

foreach()

template<typename F>

bool nodetool::peerlist_manager::foreach ( bool white, const F & f )

inline

Definition at line 305 of file net_peerlist.h.

  {
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    peers_indexed::index<by_time>::type& by_time_index = white ? m_peers_white.get<by_time>() : m_peers_gray.get<by_time>();
    for(const peers_indexed::value_type& vl: boost::adaptors::reverse(by_time_index))
      if (!f(vl))
        return false;
    return true;
  }

get_and_empty_anchor_peerlist()

bool nodetool::peerlist_manager::get_and_empty_anchor_peerlist ( std::vector< anchor_peerlist_entry > & apl )

inline

Definition at line 478 of file net_peerlist.h.

  {
    TRY_ENTRY();
 
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
 
    auto begin = m_peers_anchor.get<by_time>().begin();
    auto end = m_peers_anchor.get<by_time>().end();
 
    std::for_each(begin, end, [&apl](const anchor_peerlist_entry &a) {
      apl.push_back(a);
    });
 
    m_peers_anchor.get<by_time>().clear();
 
    return true;
 
    CATCH_ENTRY_L0("peerlist_manager::get_and_empty_anchor_peerlist()", false);
  }

Here is the caller graph for this function:

get_gray_peer_by_index()

bool nodetool::peerlist_manager::get_gray_peer_by_index ( peerlist_entry & p, size_t i )

inline

Definition at line 242 of file net_peerlist.h.

  {
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    if(i >= m_peers_gray.size())
      return false;
 
    peers_indexed::index<by_time>::type& by_time_index = m_peers_gray.get<by_time>();
    p = *epee::misc_utils::move_it_backward(--by_time_index.end(), i);    
    return true;
  }

Here is the call graph for this function:

get_gray_peers_count()

size_t nodetool::peerlist_manager::get_gray_peers_count ( )

inline

Definition at line 104 of file net_peerlist.h.

{CRITICAL_REGION_LOCAL(m_peerlist_lock); return m_peers_gray.size();}

get_peerlist() [1/2]

void nodetool::peerlist_manager::get_peerlist

(

peerlist_types &

peers

)

Definition at line 280 of file net_peerlist.cpp.

  { 
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    peers.white.reserve(peers.white.size() + m_peers_white.size());
    peers.gray.reserve(peers.gray.size() + m_peers_gray.size());
    peers.anchor.reserve(peers.anchor.size() + m_peers_anchor.size());
 
    copy_peers(peers.white, m_peers_white.get<by_addr>());
    copy_peers(peers.gray, m_peers_gray.get<by_addr>());
    copy_peers(peers.anchor, m_peers_anchor.get<by_addr>());
  }

get_peerlist() [2/2]

void nodetool::peerlist_manager::get_peerlist	(	std::vector< peerlist_entry > &	pl_gray,
		std::vector< peerlist_entry > &	pl_white )

Definition at line 273 of file net_peerlist.cpp.

  {
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    copy_peers(pl_gray, m_peers_gray.get<by_addr>());
    copy_peers(pl_white, m_peers_white.get<by_addr>());
  }

get_peerlist_head()

bool nodetool::peerlist_manager::get_peerlist_head ( std::vector< peerlist_entry > & bs_head, bool anonymize, uint32_t depth = P2P_DEFAULT_PEERS_IN_HANDSHAKE )

inline

Definition at line 267 of file net_peerlist.h.

  {
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    peers_indexed::index<by_time>::type& by_time_index=m_peers_white.get<by_time>();
    uint32_t cnt = 0;
 
    // picks a random set of peers within the first 120%, rather than a set of the first 100%.
    // The intent is that if someone asks twice, they can't easily tell:
    // - this address was not in the first list, but is in the second, so the only way this can be
    // is if its last_seen was recently reset, so this means the target node recently had a new
    // connection to that address
    // - this address was in the first list, and not in the second, which means either the address
    // was moved to the gray list (if it's not accessibe, which the attacker can check if
    // the address accepts incoming connections) or it was the oldest to still fit in the 250 items,
    // so its last_seen is old.
    const uint32_t pick_depth = anonymize ? depth + depth / 5 : depth;
    bs_head.reserve(pick_depth);
    for(const peers_indexed::value_type& vl: boost::adaptors::reverse(by_time_index))
    {
      if(cnt++ >= pick_depth)
        break;
 
      bs_head.push_back(vl);
    }
 
    if (anonymize)
    {
      std::random_shuffle(bs_head.begin(), bs_head.end());
      if (bs_head.size() > depth)
        bs_head.resize(depth);
      for (auto &e: bs_head)
        e.last_seen = 0;
    }
 
    return true;
  }

get_random_gray_peer()

bool nodetool::peerlist_manager::get_random_gray_peer ( peerlist_entry & pe )

inline

Definition at line 421 of file net_peerlist.h.

  {
    TRY_ENTRY();
 
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
 
    if (m_peers_gray.empty()) {
      return false;
    }
 
    size_t random_index = crypto::rand_idx(m_peers_gray.size());
 
    peers_indexed::index<by_time>::type& by_time_index = m_peers_gray.get<by_time>();
    pe = *epee::misc_utils::move_it_backward(--by_time_index.end(), random_index);
 
    return true;
 
    CATCH_ENTRY_L0("peerlist_manager::get_random_gray_peer()", false);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_white_peer_by_index()

bool nodetool::peerlist_manager::get_white_peer_by_index ( peerlist_entry & p, size_t i )

inline

Definition at line 230 of file net_peerlist.h.

  {
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    if(i >= m_peers_white.size())
      return false;
 
    peers_indexed::index<by_time>::type& by_time_index = m_peers_white.get<by_time>();
    p = *epee::misc_utils::move_it_backward(--by_time_index.end(), i);    
    return true;
  }

Here is the call graph for this function:

get_white_peers_count()

size_t nodetool::peerlist_manager::get_white_peers_count ( )

inline

Definition at line 103 of file net_peerlist.h.

{CRITICAL_REGION_LOCAL(m_peerlist_lock); return m_peers_white.size();}

init()

bool nodetool::peerlist_manager::init	(	peerlist_types &&	peers,
		bool	allow_local_ip )

Definition at line 259 of file net_peerlist.cpp.

  {
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
 
    if (!m_peers_white.empty() || !m_peers_gray.empty() || !m_peers_anchor.empty())
      return false;
 
    add_peers(m_peers_white.get<by_addr>(), std::move(peers.white));
    add_peers(m_peers_gray.get<by_addr>(), std::move(peers.gray));
    add_peers(m_peers_anchor.get<by_addr>(), std::move(peers.anchor));
    m_allow_local_ip = allow_local_ip;
    return true;
  }

is_host_allowed()

bool nodetool::peerlist_manager::is_host_allowed ( const epee::net_utils::network_address & address )

inline

Definition at line 254 of file net_peerlist.h.

  {
    //never allow loopback ip
    if(address.is_loopback())
      return false;
 
    if(!m_allow_local_ip && address.is_local())
      return false;
 
    return true;
  }

Here is the caller graph for this function:

merge_peerlist()

bool nodetool::peerlist_manager::merge_peerlist ( const std::vector< peerlist_entry > & outer_bs )

inline

Definition at line 217 of file net_peerlist.h.

  {
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    for(const peerlist_entry& be:  outer_bs)
    {
      append_with_peer_gray(be);
    }
    // delete extra elements
    trim_gray_peerlist();    
    return true;
  }

Here is the call graph for this function:

remove_from_peer_anchor()

bool nodetool::peerlist_manager::remove_from_peer_anchor ( const epee::net_utils::network_address & addr )

inline

Definition at line 499 of file net_peerlist.h.

  {
    TRY_ENTRY();
 
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
 
    anchor_peers_indexed::index_iterator<by_addr>::type iterator = m_peers_anchor.get<by_addr>().find(addr);
 
    if (iterator != m_peers_anchor.get<by_addr>().end()) {
      m_peers_anchor.erase(iterator);
    }
 
    return true;
 
    CATCH_ENTRY_L0("peerlist_manager::remove_from_peer_anchor()", false);
  }

Here is the caller graph for this function:

remove_from_peer_gray()

bool nodetool::peerlist_manager::remove_from_peer_gray ( const peerlist_entry & pe )

inline

Definition at line 460 of file net_peerlist.h.

  {
    TRY_ENTRY();
 
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
 
    peers_indexed::index_iterator<by_addr>::type iterator = m_peers_gray.get<by_addr>().find(pe.adr);
 
    if (iterator != m_peers_gray.get<by_addr>().end()) {
      m_peers_gray.erase(iterator);
    }
 
    return true;
 
    CATCH_ENTRY_L0("peerlist_manager::remove_from_peer_gray()", false);
  }

Here is the caller graph for this function:

remove_from_peer_white()

bool nodetool::peerlist_manager::remove_from_peer_white ( const peerlist_entry & pe )

inline

Definition at line 442 of file net_peerlist.h.

  {
    TRY_ENTRY();
 
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
 
    peers_indexed::index_iterator<by_addr>::type iterator = m_peers_white.get<by_addr>().find(pe.adr);
 
    if (iterator != m_peers_white.get<by_addr>().end()) {
      m_peers_white.erase(iterator);
    }
 
    return true;
 
    CATCH_ENTRY_L0("peerlist_manager::remove_from_peer_white()", false);
  }

Here is the caller graph for this function:

set_peer_just_seen()

bool nodetool::peerlist_manager::set_peer_just_seen ( peerid_type peer, const epee::net_utils::network_address & addr, uint32_t pruning_seed, uint16_t rpc_port )

inline

Definition at line 316 of file net_peerlist.h.

  {
    TRY_ENTRY();
    CRITICAL_REGION_LOCAL(m_peerlist_lock);
    //find in white list
    peerlist_entry ple;
    ple.adr = addr;
    ple.id = peer;
    ple.last_seen = time(NULL);
    ple.pruning_seed = pruning_seed;
    ple.rpc_port = rpc_port;
    return append_with_peer_white(ple);
    CATCH_ENTRY_L0("peerlist_manager::set_peer_just_seen()", false);
  }

Here is the call graph for this function:

set_peer_unreachable()

bool nodetool::peerlist_manager::set_peer_unreachable

(

const peerlist_entry &

pr

)

Here is the call graph for this function:

Friends And Related Symbol Documentation

boost::serialization::access

friend class boost::serialization::access

friend

Definition at line 187 of file net_peerlist.h.

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/p2p/net_peerlist.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/p2p/net_peerlist.cpp