Electroneum
nodetool Namespace Reference

Classes

struct  anchor_peerlist_entry_base
 
struct  anonymous_inbound
 
struct  basic_node_data
 
struct  COMMAND_HANDSHAKE_T
 
struct  COMMAND_PING
 
struct  COMMAND_TIMED_SYNC_T
 
struct  connection_entry_base
 
struct  i_p2p_endpoint
 
struct  network_address_old
 
struct  network_config
 
class  node_server
 
struct  p2p_connection_context_t
 
struct  p2p_endpoint_stub
 
struct  peerlist_entry_base
 
struct  peerlist_join
 
class  peerlist_manager
 
class  peerlist_storage
 
struct  peerlist_types
 
struct  proxy
 

Typedefs

typedef boost::uuids::uuid uuid
 
typedef boost::uuids::uuid net_connection_id
 
typedef uint64_t peerid_type
 
typedef peerlist_entry_base< epee::net_utils::network_addresspeerlist_entry
 
typedef anchor_peerlist_entry_base< epee::net_utils::network_addressanchor_peerlist_entry
 
typedef connection_entry_base< epee::net_utils::network_addressconnection_entry
 

Functions

boost::optional< std::vector< proxy > > get_proxies (boost::program_options::variables_map const &vm)
 
boost::optional< std::vector< anonymous_inbound > > get_anonymous_inbounds (boost::program_options::variables_map const &vm)
 
bool is_filtered_command (const epee::net_utils::network_address &address, int command)
 
boost::optional< boost::asio::ip::tcp::socket > socks_connect_internal (const std::atomic< bool > &stop_signal, boost::asio::io_service &service, const boost::asio::ip::tcp::endpoint &proxy, const epee::net_utils::network_address &remote)
 
template<typename Archive >
void serialize (Archive &a, peerlist_types &elem, unsigned ver)
 
template<typename Archive >
void serialize (Archive &a, peerlist_join elem, unsigned ver)
 
std::string print_peerlist_to_string (const std::vector< peerlist_entry > &pl)
 
crypto::hash get_proof_of_trust_hash (const nodetool::proof_of_trust &pot)
 

Variables

const command_line::arg_descriptor< std::string > arg_p2p_bind_ip = {"p2p-bind-ip", "Interface for p2p network protocol", "0.0.0.0"}
 
const command_line::arg_descriptor< std::string, false, true, 2 > arg_p2p_bind_port
 
const command_line::arg_descriptor< uint32_targ_p2p_external_port = {"p2p-external-port", "External port for p2p network protocol (if port forwarding used with NAT)", 0}
 
const command_line::arg_descriptor< boolarg_p2p_allow_local_ip = {"allow-local-ip", "Allow local ip add to peer list, mostly in debug purposes"}
 
const command_line::arg_descriptor< std::vector< std::string > > arg_p2p_add_peer = {"add-peer", "Manually add peer to local peerlist"}
 
const command_line::arg_descriptor< std::vector< std::string > > arg_p2p_add_priority_node = {"add-priority-node", "Specify list of peers to connect to and attempt to keep the connection open"}
 
const command_line::arg_descriptor< std::vector< std::string > > arg_p2p_add_exclusive_node
 
const command_line::arg_descriptor< std::vector< std::string > > arg_p2p_seed_node = {"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"}
 
const command_line::arg_descriptor< std::vector< std::string > > arg_proxy = {"proxy", "<network-type>,<socks-ip:port>[,max_connections] i.e. \"tor,127.0.0.1:9050,100\""}
 
const command_line::arg_descriptor< std::vector< std::string > > arg_anonymous_inbound = {"anonymous-inbound", "<hidden-service-address>,<[bind-ip:]port>[,max_connections] i.e. \"x.onion,127.0.0.1:18083,100\""}
 
const command_line::arg_descriptor< boolarg_p2p_hide_my_port = {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true}
 
const command_line::arg_descriptor< boolarg_no_sync = {"no-sync", "Don't synchronize the blockchain with other peers", false}
 
const command_line::arg_descriptor< boolarg_no_igd = {"no-igd", "Disable UPnP port mapping"}
 
const command_line::arg_descriptor< int64_targ_out_peers = {"out-peers", "set max number of out peers", -1}
 
const command_line::arg_descriptor< int64_targ_in_peers = {"in-peers", "set max number of in peers", -1}
 
const command_line::arg_descriptor< int > arg_tos_flag = {"tos-flag", "set TOS flag", -1}
 
const command_line::arg_descriptor< int64_targ_limit_rate_up = {"limit-rate-up", "set limit-rate-up [kB/s]", P2P_DEFAULT_LIMIT_RATE_UP}
 
const command_line::arg_descriptor< int64_targ_limit_rate_down = {"limit-rate-down", "set limit-rate-down [kB/s]", P2P_DEFAULT_LIMIT_RATE_DOWN}
 
const command_line::arg_descriptor< int64_targ_limit_rate = {"limit-rate", "set limit-rate [kB/s]", -1}
 
const command_line::arg_descriptor< boolarg_save_graph = {"save-graph", "Save data for dr electroneum", false}
 
const int64_t default_limit_up = P2P_DEFAULT_LIMIT_RATE_UP
 
const int64_t default_limit_down = P2P_DEFAULT_LIMIT_RATE_DOWN
 
const command_line::arg_descriptor< boolarg_offline
 

Typedef Documentation

◆ anchor_peerlist_entry

◆ connection_entry

◆ net_connection_id

typedef boost::uuids::uuid nodetool::net_connection_id

Definition at line 44 of file net_node_common.h.

◆ peerid_type

Definition at line 51 of file p2p_protocol_defs.h.

◆ peerlist_entry

◆ uuid

typedef boost::uuids::uuid nodetool::uuid

Definition at line 43 of file net_node_common.h.

Function Documentation

◆ get_anonymous_inbounds()

boost::optional< std::vector< anonymous_inbound > > nodetool::get_anonymous_inbounds ( boost::program_options::variables_map const &  vm)

Definition at line 206 of file net_node.cpp.

207  {
208  std::vector<anonymous_inbound> inbounds{};
209 
210  const std::vector<std::string> args = command_line::get_arg(vm, arg_anonymous_inbound);
211  inbounds.reserve(args.size());
212 
213  for (const boost::string_ref arg : args)
214  {
215  inbounds.emplace_back();
216 
217  auto next = boost::algorithm::make_split_iterator(arg, boost::algorithm::first_finder(","));
218  CHECK_AND_ASSERT_MES(!next.eof() && !next->empty(), boost::none, "No inbound address for --" << arg_anonymous_inbound.name);
219  const boost::string_ref address{next->begin(), next->size()};
220 
221  ++next;
222  CHECK_AND_ASSERT_MES(!next.eof() && !next->empty(), boost::none, "No local ipv4:port given for --" << arg_anonymous_inbound.name);
223  const boost::string_ref bind{next->begin(), next->size()};
224 
225  const std::size_t colon = bind.find_first_of(':');
226  CHECK_AND_ASSERT_MES(colon < bind.size(), boost::none, "No local port given for --" << arg_anonymous_inbound.name);
227 
228  ++next;
229  if (!next.eof())
230  {
231  inbounds.back().max_connections = get_max_connections(*next);
232  if (inbounds.back().max_connections == 0)
233  {
234  MERROR("Invalid max connections given to --" << arg_proxy.name);
235  return boost::none;
236  }
237  }
238 
240  switch (our_address ? our_address->get_type_id() : epee::net_utils::address_type::invalid)
241  {
243  inbounds.back().our_address = std::move(*our_address);
244  inbounds.back().default_remote = net::tor_address::unknown();
245  break;
247  inbounds.back().our_address = std::move(*our_address);
248  inbounds.back().default_remote = net::i2p_address::unknown();
249  break;
250  default:
251  MERROR("Invalid inbound address (" << address << ") for --" << arg_anonymous_inbound.name << ": " << (our_address ? "invalid type" : our_address.error().message()));
252  return boost::none;
253  }
254 
255  // get_address returns default constructed address on error
256  if (inbounds.back().our_address == epee::net_utils::network_address{})
257  return boost::none;
258 
259  std::uint32_t ip = 0;
260  std::uint16_t port = 0;
262  {
263  MERROR("Invalid ipv4:port given for --" << arg_anonymous_inbound.name);
264  return boost::none;
265  }
266  inbounds.back().local_ip = std::string{bind.substr(0, colon)};
267  inbounds.back().local_port = std::string{bind.substr(colon + 1)};
268  }
269 
270  return inbounds;
271  }
#define MERROR(x)
Definition: misc_log_ex.h:73
const command_line::arg_descriptor< std::vector< std::string > > arg_anonymous_inbound
Definition: net_node.cpp:133
::std::string string
Definition: gtest-port.h:1097
#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)
Definition: misc_log_ex.h:181
static i2p_address unknown() noexcept
Definition: i2p_address.h:70
STL namespace.
unsigned short uint16_t
Definition: stdint.h:125
static tor_address unknown() noexcept
Definition: tor_address.h:70
std::error_code error() const noexcept
Definition: expect.h:276
const command_line::arg_descriptor< std::vector< std::string > > arg_proxy
Definition: net_node.cpp:132
address_type get_type_id() const
unsigned int uint32_t
Definition: stdint.h:126
expect< epee::net_utils::network_address > get_network_address(const boost::string_ref address, const std::uint16_t default_port)
Definition: parse.cpp:38
Definition: expect.h:70
static constexpr epee::net_utils::address_type get_type_id() noexcept
Definition: tor_address.h:112
boost::endian::big_uint32_t ip
Definition: socks.cpp:61
boost::endian::big_uint16_t port
Definition: socks.cpp:60
const T & move(const T &t)
Definition: gtest-port.h:1317
T get_arg(const boost::program_options::variables_map &vm, const arg_descriptor< T, false, true > &arg)
Definition: command_line.h:271
const char * address
Definition: multisig.cpp:37
static constexpr epee::net_utils::address_type get_type_id() noexcept
Definition: i2p_address.h:112
bool parse_peer_from_string(uint32_t &ip, uint16_t &port, const std::string &addres)
Definition: string_tools.h:174
Here is the call graph for this function:

◆ get_proof_of_trust_hash()

crypto::hash nodetool::get_proof_of_trust_hash ( const nodetool::proof_of_trust &  pot)
inline

Definition at line 485 of file p2p_protocol_defs.h.

486  {
487  std::string s;
488  s.append(reinterpret_cast<const char*>(&pot.peer_id), sizeof(pot.peer_id));
489  s.append(reinterpret_cast<const char*>(&pot.time), sizeof(pot.time));
490  return crypto::cn_fast_hash(s.data(), s.size());
491  }
::std::string string
Definition: gtest-port.h:1097
void cn_fast_hash(const void *data, size_t length, char *hash)
Here is the call graph for this function:

◆ get_proxies()

boost::optional< std::vector< proxy > > nodetool::get_proxies ( boost::program_options::variables_map const &  vm)

Definition at line 148 of file net_node.cpp.

149  {
150  namespace ip = boost::asio::ip;
151 
152  std::vector<proxy> proxies{};
153 
154  const std::vector<std::string> args = command_line::get_arg(vm, arg_proxy);
155  proxies.reserve(args.size());
156 
157  for (const boost::string_ref arg : args)
158  {
159  proxies.emplace_back();
160 
161  auto next = boost::algorithm::make_split_iterator(arg, boost::algorithm::first_finder(","));
162  CHECK_AND_ASSERT_MES(!next.eof() && !next->empty(), boost::none, "No network type for --" << arg_proxy.name);
163  const boost::string_ref zone{next->begin(), next->size()};
164 
165  ++next;
166  CHECK_AND_ASSERT_MES(!next.eof() && !next->empty(), boost::none, "No ipv4:port given for --" << arg_proxy.name);
167  const boost::string_ref proxy{next->begin(), next->size()};
168 
169  ++next;
170  if (!next.eof())
171  {
172  proxies.back().max_connections = get_max_connections(*next);
173  if (proxies.back().max_connections == 0)
174  {
175  MERROR("Invalid max connections given to --" << arg_proxy.name);
176  return boost::none;
177  }
178  }
179 
181  {
183  proxies.back().zone = epee::net_utils::zone::tor;
184  break;
186  proxies.back().zone = epee::net_utils::zone::i2p;
187  break;
188  default:
189  MERROR("Invalid network for --" << arg_proxy.name);
190  return boost::none;
191  }
192 
193  std::uint32_t ip = 0;
194  std::uint16_t port = 0;
196  {
197  MERROR("Invalid ipv4:port given for --" << arg_proxy.name);
198  return boost::none;
199  }
200  proxies.back().address = ip::tcp::endpoint{ip::address_v4{boost::endian::native_to_big(ip)}, port};
201  }
202 
203  return proxies;
204  }
#define MERROR(x)
Definition: misc_log_ex.h:73
zone zone_from_string(boost::string_ref value) noexcept
::std::string string
Definition: gtest-port.h:1097
#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)
Definition: misc_log_ex.h:181
unsigned short uint16_t
Definition: stdint.h:125
const command_line::arg_descriptor< std::vector< std::string > > arg_proxy
Definition: net_node.cpp:132
unsigned int uint32_t
Definition: stdint.h:126
boost::endian::big_uint32_t ip
Definition: socks.cpp:61
boost::endian::big_uint16_t port
Definition: socks.cpp:60
T get_arg(const boost::program_options::variables_map &vm, const arg_descriptor< T, false, true > &arg)
Definition: command_line.h:271
bool parse_peer_from_string(uint32_t &ip, uint16_t &port, const std::string &addres)
Definition: string_tools.h:174
Here is the call graph for this function:

◆ is_filtered_command()

bool nodetool::is_filtered_command ( epee::net_utils::network_address const &  address,
int  command 
)
Returns
True if commnd is filtered (ignored/dropped) for address

Definition at line 273 of file net_node.cpp.

274  {
275  switch (command)
276  {
280  return false;
281  default:
282  break;
283  }
284 
285  if (address.get_zone() == epee::net_utils::zone::public_)
286  return false;
287 
288  MWARNING("Filtered command (#" << command << ") to/from " << address.str());
289  return true;
290  }
#define MWARNING(x)
Definition: misc_log_ex.h:74
const char * address
Definition: multisig.cpp:37

◆ print_peerlist_to_string()

std::string nodetool::print_peerlist_to_string ( const std::vector< peerlist_entry > &  pl)
inline

Definition at line 126 of file p2p_protocol_defs.h.

127  {
128  time_t now_time = 0;
129  time(&now_time);
130  std::stringstream ss;
131  ss << std::setfill ('0') << std::setw (8) << std::hex << std::noshowbase;
132  for(const peerlist_entry& pe: pl)
133  {
134  ss << pe.id << "\t" << pe.adr.str()
135  << " \trpc port " << (pe.rpc_port > 0 ? std::to_string(pe.rpc_port) : "-")
136  << " \tpruning seed " << pe.pruning_seed
137  << " \tlast_seen: " << (pe.last_seen == 0 ? std::string("never") : epee::misc_utils::get_time_interval_string(now_time - pe.last_seen))
138  << std::endl;
139  }
140  return ss.str();
141  }
::std::string string
Definition: gtest-port.h:1097
peerlist_entry_base< epee::net_utils::network_address > peerlist_entry
STL namespace.
time_t time
Definition: blockchain.cpp:93
std::string get_time_interval_string(const time_t &time_)
Definition: time_helper.h:120
std::string to_string(t_connection_type type)

◆ serialize() [1/2]

template<typename Archive >
void nodetool::serialize ( Archive &  a,
peerlist_types elem,
unsigned  ver 
)

Definition at line 139 of file net_peerlist.cpp.

140  {
141  elem.white = load_peers<peerlist_entry>(a, ver);
142  elem.gray = load_peers<peerlist_entry>(a, ver);
143  elem.anchor = load_peers<anchor_peerlist_entry>(a, ver);
144 
145  if (ver == 0)
146  {
147  // from v1, we do not store the peer id anymore
148  peerid_type peer_id{};
149  a & peer_id;
150  }
151  }
uint64_t peerid_type
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [2/2]

template<typename Archive >
void nodetool::serialize ( Archive &  a,
peerlist_join  elem,
unsigned  ver 
)

Definition at line 154 of file net_peerlist.cpp.

155  {
156  save_peers(a, boost::range::join(elem.ours.white, elem.other.white));
157  save_peers(a, boost::range::join(elem.ours.gray, elem.other.gray));
158  save_peers(a, boost::range::join(elem.ours.anchor, elem.other.anchor));
159  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ socks_connect_internal()

boost::optional< boost::asio::ip::tcp::socket > nodetool::socks_connect_internal ( const std::atomic< bool > &  stop_signal,
boost::asio::io_service &  service,
const boost::asio::ip::tcp::endpoint &  proxy,
const epee::net_utils::network_address remote 
)

Definition at line 293 of file net_node.cpp.

294  {
295  using socket_type = net::socks::client::stream_type::socket;
296  using client_result = std::pair<boost::system::error_code, socket_type>;
297 
298  struct notify
299  {
300  boost::promise<client_result> socks_promise;
301 
302  void operator()(boost::system::error_code error, socket_type&& sock)
303  {
304  socks_promise.set_value(std::make_pair(error, std::move(sock)));
305  }
306  };
307 
308  boost::unique_future<client_result> socks_result{};
309  {
310  boost::promise<client_result> socks_promise{};
311  socks_result = socks_promise.get_future();
312 
313  auto client = net::socks::make_connect_client(
314  boost::asio::ip::tcp::socket{service}, net::socks::version::v4a, notify{std::move(socks_promise)}
315  );
316  if (!start_socks(std::move(client), proxy, remote))
317  return boost::none;
318  }
319 
320  const auto start = std::chrono::steady_clock::now();
321  while (socks_result.wait_for(future_poll_interval) == boost::future_status::timeout)
322  {
323  if (socks_connect_timeout < std::chrono::steady_clock::now() - start)
324  {
325  MERROR("Timeout on socks connect (" << proxy << " to " << remote.str() << ")");
326  return boost::none;
327  }
328 
329  if (stop_signal)
330  return boost::none;
331  }
332 
333  try
334  {
335  auto result = socks_result.get();
336  if (!result.first)
337  return {std::move(result.second)};
338 
339  MERROR("Failed to make socks connection to " << remote.str() << " (via " << proxy << "): " << result.first.message());
340  }
341  catch (boost::broken_promise const&)
342  {}
343 
344  return boost::none;
345  }
#define MERROR(x)
Definition: misc_log_ex.h:73
std::unique_ptr< void, close > socket
Unique ZMQ socket handle, calls zmq_close on destruction.
Definition: zmq.h:101
std::shared_ptr< client > make_connect_client(client::stream_type::socket &&proxy, socks::version ver, Handler handler)
Definition: socks.h:226
const T & move(const T &t)
Definition: gtest-port.h:1317
error
Tracks LMDB error codes.
Definition: error.h:44
Here is the call graph for this function:

Variable Documentation

◆ arg_anonymous_inbound

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_anonymous_inbound = {"anonymous-inbound", "<hidden-service-address>,<[bind-ip:]port>[,max_connections] i.e. \"x.onion,127.0.0.1:18083,100\""}

Definition at line 133 of file net_node.cpp.

◆ arg_in_peers

const command_line::arg_descriptor< int64_t > nodetool::arg_in_peers = {"in-peers", "set max number of in peers", -1}

Definition at line 139 of file net_node.cpp.

◆ arg_limit_rate

const command_line::arg_descriptor< int64_t > nodetool::arg_limit_rate = {"limit-rate", "set limit-rate [kB/s]", -1}

Definition at line 144 of file net_node.cpp.

◆ arg_limit_rate_down

const command_line::arg_descriptor< int64_t > nodetool::arg_limit_rate_down = {"limit-rate-down", "set limit-rate-down [kB/s]", P2P_DEFAULT_LIMIT_RATE_DOWN}

Definition at line 143 of file net_node.cpp.

◆ arg_limit_rate_up

const command_line::arg_descriptor< int64_t > nodetool::arg_limit_rate_up = {"limit-rate-up", "set limit-rate-up [kB/s]", P2P_DEFAULT_LIMIT_RATE_UP}

Definition at line 142 of file net_node.cpp.

◆ arg_no_igd

const command_line::arg_descriptor< bool > nodetool::arg_no_igd = {"no-igd", "Disable UPnP port mapping"}

Definition at line 137 of file net_node.cpp.

◆ arg_no_sync

const command_line::arg_descriptor< bool > nodetool::arg_no_sync = {"no-sync", "Don't synchronize the blockchain with other peers", false}

Definition at line 135 of file net_node.cpp.

◆ arg_offline

const command_line::arg_descriptor<bool> nodetool::arg_offline

Definition at line 109 of file cryptonote_core.cpp.

◆ arg_out_peers

const command_line::arg_descriptor< int64_t > nodetool::arg_out_peers = {"out-peers", "set max number of out peers", -1}

Definition at line 138 of file net_node.cpp.

◆ arg_p2p_add_exclusive_node

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_p2p_add_exclusive_node
Initial value:
= {"add-exclusive-node", "Specify list of peers to connect to only."
" If this option is given the options add-priority-node and seed-node are ignored"}

Definition at line 129 of file net_node.cpp.

◆ arg_p2p_add_peer

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_p2p_add_peer = {"add-peer", "Manually add peer to local peerlist"}

Definition at line 127 of file net_node.cpp.

◆ arg_p2p_add_priority_node

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_p2p_add_priority_node = {"add-priority-node", "Specify list of peers to connect to and attempt to keep the connection open"}

Definition at line 128 of file net_node.cpp.

◆ arg_p2p_allow_local_ip

const command_line::arg_descriptor< bool > nodetool::arg_p2p_allow_local_ip = {"allow-local-ip", "Allow local ip add to peer list, mostly in debug purposes"}

Definition at line 126 of file net_node.cpp.

◆ arg_p2p_bind_ip

const command_line::arg_descriptor< std::string > nodetool::arg_p2p_bind_ip = {"p2p-bind-ip", "Interface for p2p network protocol", "0.0.0.0"}

Definition at line 111 of file net_node.cpp.

◆ arg_p2p_bind_port

const command_line::arg_descriptor< std::string, false, true, 2 > nodetool::arg_p2p_bind_port
Initial value:
= {
"p2p-bind-port"
, "Port for p2p network protocol"
, [](std::array<bool, 2> testnet_stagenet, bool defaulted, std::string val)->std::string {
if (testnet_stagenet[0] && defaulted)
else if (testnet_stagenet[1] && defaulted)
return val;
}
}
uint16_t const P2P_DEFAULT_PORT
uint16_t const P2P_DEFAULT_PORT
::std::string string
Definition: gtest-port.h:1097
const command_line::arg_descriptor< bool, false > arg_stagenet_on
uint16_t const P2P_DEFAULT_PORT
const command_line::arg_descriptor< bool, false > arg_testnet_on
std::string to_string(t_connection_type type)

Definition at line 112 of file net_node.cpp.

◆ arg_p2p_external_port

const command_line::arg_descriptor< uint32_t > nodetool::arg_p2p_external_port = {"p2p-external-port", "External port for p2p network protocol (if port forwarding used with NAT)", 0}

Definition at line 125 of file net_node.cpp.

◆ arg_p2p_hide_my_port

const command_line::arg_descriptor< bool > nodetool::arg_p2p_hide_my_port = {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true}

Definition at line 134 of file net_node.cpp.

◆ arg_p2p_seed_node

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_p2p_seed_node = {"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"}

Definition at line 131 of file net_node.cpp.

◆ arg_proxy

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_proxy = {"proxy", "<network-type>,<socks-ip:port>[,max_connections] i.e. \"tor,127.0.0.1:9050,100\""}

Definition at line 132 of file net_node.cpp.

◆ arg_save_graph

const command_line::arg_descriptor< bool > nodetool::arg_save_graph = {"save-graph", "Save data for dr electroneum", false}

Definition at line 146 of file net_node.cpp.

◆ arg_tos_flag

const command_line::arg_descriptor< int > nodetool::arg_tos_flag = {"tos-flag", "set TOS flag", -1}

Definition at line 140 of file net_node.cpp.

◆ default_limit_down

const int64_t nodetool::default_limit_down = P2P_DEFAULT_LIMIT_RATE_DOWN

Definition at line 482 of file net_node.h.

◆ default_limit_up

const int64_t nodetool::default_limit_up = P2P_DEFAULT_LIMIT_RATE_UP

Definition at line 481 of file net_node.h.