lukechilds
/
ethminer
mirror of https://github.com/lukechilds/ethminer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Persist host identifier to disk. Replace noteNode with addNode. Add udp node port to connect. Add addNode to node table which pings node, potentially adding node to table if node respons. Rename NodeEndpoint to NodeIPEndpoint.

cl-refactor
subtly 10 years ago
parent
da9668c0f5
commit
fa11fc0149
5 changed files with 182 additions and 123 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 184
      libp2p/Host.cpp
  2. 34
      libp2p/Host.h
  3. 19
      libp2p/NodeTable.cpp
  4. 40
      libp2p/NodeTable.h
  5. 28
      libp2p/Session.cpp

184
libp2p/Host.cpp
View File

@ -28,6 +28,7 @@
#include <libdevcore/Common.h>
#include <libdevcore/CommonIO.h>
#include <libethcore/Exceptions.h>
#include <devcrypto/FileSystem.h>
#include "Session.h"
#include "Common.h"
#include "Capability.h"
@ -44,14 +45,14 @@ Host::Host(std::string const& _clientVersion, NetworkPreferences const& _n, bool
m_ifAddresses(Network::getInterfaceAddresses()),
m_ioService(2),
m_tcp4Acceptor(m_ioService),
m_key(KeyPair::create()),
m_key(move(getHostIdentifier())),
m_nodeTable(new NodeTable(m_ioService, m_key))
{
for (auto address: m_ifAddresses)
if (address.is_v4())
clog(NetNote) << "IP Address: " << address << " = " << (isPrivateAddress(address) ? "[LOCAL]" : "[PEER]");
clog(NetNote) << "Id:" << id().abridged();
clog(NetNote) << "Id:" << id();
if (_start)
start();
}
@ -178,69 +179,78 @@ void Host::seal(bytes& _b)
_b[7] = len & 0xff;
}
// TODO P2P: remove oldid. port to NodeTable. (see noteNode calls, Session.cpp#218,337)
shared_ptr<NodeInfo> Host::noteNode(NodeId _id, bi::tcp::endpoint _a, NodeId _oldId)
{
RecursiveGuard l(x_peers);
if (_a.port() < 30300 || _a.port() > 30305)
cwarn << "Weird port being recorded: " << _a.port();
if (_a.port() >= /*49152*/32768)
{
cwarn << "Private port being recorded - setting to 0";
_a = bi::tcp::endpoint(_a.address(), 0);
}
// TODO: P2P port to NodeTable. (see noteNode calls, Session.cpp)
//shared_ptr<NodeInfo> Host::noteNode(NodeId _id, bi::tcp::endpoint _a)
//{
// RecursiveGuard l(x_peers);
// if (_a.port() < 30300 || _a.port() > 30305)
// cwarn << "Weird port being recorded: " << _a.port();
//
// if (_a.port() >= /*49152*/32768)
// {
// cwarn << "Private port being recorded - setting to 0";
// _a = bi::tcp::endpoint(_a.address(), 0);
// }
//
// unsigned i;
// if (!m_nodes.count(_id))
// {
// i = m_nodesList.size();
// m_nodesList.push_back(_id);
// m_nodes[_id] = make_shared<NodeInfo>();
// m_nodes[_id]->id = _id;
// m_nodes[_id]->index = i;
// }
// else
// i = m_nodes[_id]->index;
// m_nodes[_id]->address = _a;
// m_private.extendAll(i);
// if (!_a.port() || (isPrivateAddress(_a.address()) && !m_netPrefs.localNetworking))
// m_private += i;
// else
// m_private -= i;
//
// return m_nodes[_id];
//}
// First check for another node with the same connection credentials, and put it in oldId if found.
if (!_oldId)
for (pair<h512, shared_ptr<NodeInfo>> const& n: m_nodes)
if (n.second->address == _a && n.second->id != _id)
{
_oldId = n.second->id;
break;
}
// TODO: P2P base on target
// TODO: P2P store caps in NodeTable/NodeEntry
//Nodes Host::potentialPeers(RangeMask<unsigned> const& _known)
//{
// RecursiveGuard l(x_peers);
// Nodes ret;
//
// // todo: if localnetworking is enabled it should only share peers if remote
// // is within the same network as our interfaces.
// // this requires flagging nodes when we receive them as to if they're on private network
// auto ns = (m_netPrefs.localNetworking ? _known : (m_private + _known)).inverted();
// for (auto i: ns)
// ret.push_back(*m_nodes[m_nodesList[i]]);
// return ret;
//}
unsigned i;
if (!m_nodes.count(_id))
KeyPair Host::getHostIdentifier()
{
static string s_file(getDataDir() + "/host");
static mutex s_x;
lock_guard<mutex> l(s_x);
h256 secret;
bytes b = contents(s_file);
if (b.size() == 32)
memcpy(secret.data(), b.data(), 32);
else
{
if (m_nodes.count(_oldId))
{
i = m_nodes[_oldId]->index;
m_nodes.erase(_oldId);
m_nodesList[i] = _id;
}
else
{
i = m_nodesList.size();
m_nodesList.push_back(_id);
}
m_nodes[_id] = make_shared<NodeInfo>();
m_nodes[_id]->id = _id;
m_nodes[_id]->index = i;
// todo: replace w/user entropy; abstract to devcrypto
std::mt19937_64 s_eng(time(0) + chrono::high_resolution_clock::now().time_since_epoch().count());
std::uniform_int_distribution<uint16_t> d(0, 255);
for (unsigned i = 0; i < 32; ++i)
secret[i] = (byte)d(s_eng);
}
else
i = m_nodes[_id]->index;
m_nodes[_id]->address = _a;
m_private.extendAll(i);
if (!_a.port() || (isPrivateAddress(_a.address()) && !m_netPrefs.localNetworking))
m_private += i;
else
m_private -= i;
return m_nodes[_id];
}
// TODO P2P: should be based on target
// TODO P2P: store caps in NodeTable/NodeEntry
Nodes Host::potentialPeers(RangeMask<unsigned> const& _known)
{
RecursiveGuard l(x_peers);
Nodes ret;
auto ns = (m_netPrefs.localNetworking ? _known : (m_private + _known)).inverted();
for (auto i: ns)
ret.push_back(*m_nodes[m_nodesList[i]]);
return ret;
if (!secret)
BOOST_THROW_EXCEPTION(crypto::InvalidState());
return move(KeyPair(move(secret)));
}
void Host::determinePublic(string const& _publicAddress, bool _upnp)
@ -366,9 +376,25 @@ string Host::pocHost()
return "poc-" + strs[1] + ".ethdev.com";
}
// TODO P2P: support for TCP+UDP when manually connecting
// TODO P2P: remove in favor of addNode(NodeId, string, uint16_t, bool _required = false)
void Host::connect(NodeId const& _node, std::string const& _addr, unsigned short _port) noexcept
void Host::addNode(NodeId const& _node, std::string const& _addr, unsigned short _tcpPeerPort, unsigned short _udpNodePort)
{
boost::system::error_code ec;
bi::address addr = bi::address::from_string(_addr, ec);
if (ec)
{
bi::tcp::resolver r(m_ioService);
r.async_resolve({_addr, toString(_tcpPeerPort)}, [=](boost::system::error_code const& _ec, bi::tcp::resolver::iterator _epIt) {
if (_ec)
return;
bi::tcp::endpoint tcp = *_epIt;
addNode(Node(_node, NodeIPEndpoint(bi::udp::endpoint(tcp.address(), _udpNodePort), tcp)));
});
}
else
addNode(Node(_node, NodeIPEndpoint(bi::udp::endpoint(addr, _udpNodePort), bi::tcp::endpoint(addr, _tcpPeerPort))));
}
void Host::connect(NodeId const& _node, std::string const& _addr, unsigned short _peerPort, unsigned short _nodePort) noexcept
{
if (!m_run)
return;
@ -388,10 +414,10 @@ void Host::connect(NodeId const& _node, std::string const& _addr, unsigned short
if (first)
{
bi::tcp::resolver r(m_ioService);
ep = r.resolve({_addr, toString(_port)})->endpoint();
ep = r.resolve({_addr, toString(_peerPort)})->endpoint();
}
else
ep = bi::tcp::endpoint(bi::address::from_string(_addr), _port);
ep = bi::tcp::endpoint(bi::address::from_string(_addr), _peerPort);
if (!n)
m_nodes[_node] = make_shared<NodeInfo>();
@ -494,8 +520,8 @@ unsigned NodeInfo::fallbackSeconds() const
}
}
// TODO P2P: rebuild noetable when localNetworking is enabled/disabled
// TODO P2P: migrate grow/prunePeers into 'maintainPeers' & evaluate reputation instead of availability. schedule via deadline timer.
// TODO: P2P rebuild noetable when localNetworking is enabled/disabled
// TODO: P2P migrate grow/prunePeers into 'maintainPeers' & evaluate reputation instead of availability. schedule via deadline timer.
//void Host::growPeers()
//{
// RecursiveGuard l(x_peers);
@ -663,7 +689,6 @@ void Host::pingAll()
m_lastPing = chrono::steady_clock::now();
}
// TODO P2P: integration: todo save/restoreNodes
bytes Host::saveNodes() const
{
RLPStream nodes;
@ -704,9 +729,8 @@ void Host::restoreNodes(bytesConstRef _b)
{
case 0:
{
auto oldId = id();
m_key = KeyPair(r[1].toHash<Secret>());
noteNode(id(), m_tcpPublic, oldId);
// noteNode(id(), m_tcpPublic);
for (auto i: r[2])
{
@ -718,14 +742,14 @@ void Host::restoreNodes(bytesConstRef _b)
auto id = (NodeId)i[2];
if (!m_nodes.count(id))
{
// auto o = (Origin)i[3].toInt<int>();
auto n = noteNode(id, ep);
n->lastConnected = chrono::system_clock::time_point(chrono::seconds(i[4].toInt<unsigned>()));
n->lastAttempted = chrono::system_clock::time_point(chrono::seconds(i[5].toInt<unsigned>()));
n->failedAttempts = i[6].toInt<unsigned>();
n->lastDisconnect = (DisconnectReason)i[7].toInt<unsigned>();
n->score = (int)i[8].toInt<unsigned>();
n->rating = (int)i[9].toInt<unsigned>();
//// auto o = (Origin)i[3].toInt<int>();
// auto n = noteNode(id, ep);
// n->lastConnected = chrono::system_clock::time_point(chrono::seconds(i[4].toInt<unsigned>()));
// n->lastAttempted = chrono::system_clock::time_point(chrono::seconds(i[5].toInt<unsigned>()));
// n->failedAttempts = i[6].toInt<unsigned>();
// n->lastDisconnect = (DisconnectReason)i[7].toInt<unsigned>();
// n->score = (int)i[8].toInt<unsigned>();
// n->rating = (int)i[9].toInt<unsigned>();
}
}
}
@ -742,7 +766,7 @@ void Host::restoreNodes(bytesConstRef _b)
ep = bi::tcp::endpoint(bi::address_v4(i[0].toArray<byte, 4>()), i[1].toInt<short>());
else
ep = bi::tcp::endpoint(bi::address_v6(i[0].toArray<byte, 16>()), i[1].toInt<short>());
auto n = noteNode(id, ep);
// auto n = noteNode(id, ep);
}
}
}

34
libp2p/Host.h
View File

@ -56,7 +56,7 @@ struct NodeInfo
NodeId id; ///< Their id/public key.
unsigned index; ///< Index into m_nodesList
// p2p: move to NodeEndpoint
// p2p: move to NodeIPEndpoint
bi::tcp::endpoint address; ///< As reported from the node itself.
// p2p: This information is relevant to the network-stack, ex: firewall, rather than node itself
@ -73,14 +73,14 @@ struct NodeInfo
int score = 0; ///< All time cumulative.
int rating = 0; ///< Trending.
// p2p: move to NodeEndpoint
// p2p: move to NodeIPEndpoint
int secondsSinceLastConnected() const { return lastConnected == std::chrono::system_clock::time_point() ? -1 : (int)std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - lastConnected).count(); }
// p2p: move to NodeEndpoint
// p2p: move to NodeIPEndpoint
int secondsSinceLastAttempted() const { return lastAttempted == std::chrono::system_clock::time_point() ? -1 : (int)std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - lastAttempted).count(); }
// p2p: move to NodeEndpoint
// p2p: move to NodeIPEndpoint
unsigned fallbackSeconds() const;
// p2p: move to NodeEndpoint
// p2p: move to NodeIPEndpoint
bool shouldReconnect() const { return std::chrono::system_clock::now() > lastAttempted + std::chrono::seconds(fallbackSeconds()); }
// p2p: This has two meanings now. It's possible UDP works but TPC is down (unable to punch hole).
@ -114,6 +114,7 @@ using Nodes = std::vector<NodeInfo>;
* @brief The Host class
* Capabilities should be registered prior to startNetwork, since m_capabilities is not thread-safe.
* @todo determinePublic: ipv6, udp
* @todo handle conflict if addNode/requireNode called and Node already exists w/conflicting tcp or udp port
*/
class Host: public Worker
{
@ -128,6 +129,9 @@ public:
/// Will block on network process events.
virtual ~Host();
/// Default host for current version of client.
static std::string pocHost();
/// Basic peer network protocol version.
unsigned protocolVersion() const;
@ -137,10 +141,12 @@ public:
bool haveCapability(CapDesc const& _name) const { return m_capabilities.count(_name) != 0; }
CapDescs caps() const { CapDescs ret; for (auto const& i: m_capabilities) ret.push_back(i.first); return ret; }
template <class T> std::shared_ptr<T> cap() const { try { return std::static_pointer_cast<T>(m_capabilities.at(std::make_pair(T::staticName(), T::staticVersion()))); } catch (...) { return nullptr; } }
/// Manually add node.
void addNode(NodeId const& _node, std::string const& _addr, unsigned short _tcpPort = 30303, unsigned short _udpPort = 30303);
/// Connect to a peer explicitly.
static std::string pocHost();
void connect(NodeId const& _node, std::string const& _addr, unsigned short _port = 30303) noexcept;
void connect(NodeId const& _node, std::string const& _addr, unsigned short _tcpPort = 30303, unsigned short _udpPort = 30303) noexcept;
void connect(NodeId const& _node, bi::tcp::endpoint const& _ep);
void connect(std::shared_ptr<NodeInfo> const& _n);
@ -192,6 +198,8 @@ public:
std::shared_ptr<NodeInfo> node(NodeId _id) const { if (m_nodes.count(_id)) return m_nodes.at(_id); return std::shared_ptr<NodeInfo>(); }
private:
KeyPair getHostIdentifier();
/// Populate m_peerAddresses with available public addresses.
void determinePublic(std::string const& _publicAddress, bool _upnp);
@ -213,9 +221,11 @@ private:
/// Shutdown network. Not thread-safe; to be called only by worker.
virtual void doneWorking();
/// Add node
void addNode(Node const& _nodeInfo) { m_nodeTable->addNode(_nodeInfo); }
std::shared_ptr<NodeInfo> noteNode(NodeId _id, bi::tcp::endpoint _a, NodeId _oldId = NodeId());
Nodes potentialPeers(RangeMask<unsigned> const& _known);
// Nodes potentialPeers(RangeMask<unsigned> const& _known);
bool m_run = false; ///< Whether network is running.
std::mutex x_runTimer; ///< Start/stop mutex.
@ -254,10 +264,10 @@ private:
/// TODO: mutex; replace with nodeTable
std::map<NodeId, std::shared_ptr<NodeInfo> > m_nodes;
/// A list of node IDs. This contains every index from m_nodes; the order is guaranteed to remain the same.
std::vector<NodeId> m_nodesList;
// /// A list of node IDs. This contains every index from m_nodes; the order is guaranteed to remain the same.
// std::vector<NodeId> m_nodesList;
RangeMask<unsigned> m_private; ///< Indices into m_nodesList over to which nodes are private.
// RangeMask<unsigned> m_private; ///< Indices into m_nodesList over to which nodes are private.
unsigned m_idealPeerCount = 5; ///< Ideal number of peers to be connected to.

19
libp2p/NodeTable.cpp
View File

@ -24,8 +24,8 @@ using namespace std;
using namespace dev;
using namespace dev::p2p;
NodeEntry::NodeEntry(Node _src, Public _pubk, NodeDefaultEndpoint _gw): Node(_pubk, _gw), distance(NodeTable::dist(_src.id,_pubk)) {}
NodeEntry::NodeEntry(Node _src, Public _pubk, bi::udp::endpoint _udp): Node(_pubk, NodeDefaultEndpoint(_udp)), distance(NodeTable::dist(_src.id,_pubk)) {}
NodeEntry::NodeEntry(Node _src, Public _pubk, NodeIPEndpoint _gw): Node(_pubk, _gw), distance(NodeTable::dist(_src.id,_pubk)) {}
NodeEntry::NodeEntry(Node _src, Public _pubk, bi::udp::endpoint _udp): Node(_pubk, NodeIPEndpoint(_udp)), distance(NodeTable::dist(_src.id,_pubk)) {}
NodeTable::NodeTable(ba::io_service& _io, KeyPair _alias, uint16_t _udp, bi::tcp::endpoint _ep):
m_node(Node(_alias.pub(), bi::udp::endpoint())),
@ -240,15 +240,24 @@ void NodeTable::evict(shared_ptr<NodeEntry> _leastSeen, shared_ptr<NodeEntry> _n
}
shared_ptr<NodeEntry> NodeTable::addNode(Public const& _pubk, bi::udp::endpoint const& _udp, bi::tcp::endpoint const& _tcp)
{
auto node = Node(_pubk, NodeIPEndpoint(_udp, _tcp));
return move(addNode(node));
}
shared_ptr<NodeEntry> NodeTable::addNode(Node const& _node)
{
shared_ptr<NodeEntry> ret;
Guard l(x_nodes);
if (auto n = m_nodes[_pubk])
if (auto n = m_nodes[_node.id])
ret = n;
else
{
ret.reset(new NodeEntry(m_node, _pubk, _udp));
m_nodes[_pubk] = ret;
ret.reset(new NodeEntry(m_node, _node.id, NodeIPEndpoint(_node.endpoint.udp, _node.endpoint.tcp)));
m_nodes[_node.id] = ret;
PingNode p(_node.endpoint.udp, m_node.endpoint.udp.address().to_string(), m_node.endpoint.udp.port());
p.sign(m_secret);
m_socketPtr->send(p);
}
return move(ret);
}

40
libp2p/NodeTable.h
View File

@ -31,37 +31,45 @@ namespace dev
namespace p2p
{
struct NodeDefaultEndpoint
/**
* @brief IPv4,UDP/TCP endpoints.
*/
struct NodeIPEndpoint
{
NodeDefaultEndpoint(bi::udp::endpoint _udp): udp(_udp) {}
NodeDefaultEndpoint(bi::tcp::endpoint _tcp): tcp(_tcp) {}
NodeDefaultEndpoint(bi::udp::endpoint _udp, bi::tcp::endpoint _tcp): udp(_udp), tcp(_tcp) {}
NodeIPEndpoint(bi::udp::endpoint _udp): udp(_udp) {}
NodeIPEndpoint(bi::tcp::endpoint _tcp): tcp(_tcp) {}
NodeIPEndpoint(bi::udp::endpoint _udp, bi::tcp::endpoint _tcp): udp(_udp), tcp(_tcp) {}
bi::udp::endpoint udp;
bi::tcp::endpoint tcp;
};
struct Node
{
Node(Public _pubk, NodeDefaultEndpoint _udp): id(_pubk), endpoint(_udp) {}
Node(Public _pubk, bi::udp::endpoint _udp): Node(_pubk, NodeDefaultEndpoint(_udp)) {}
Node(Public _pubk, NodeIPEndpoint _ip, bool _required = false): id(_pubk), endpoint(_ip), required(_required) {}
Node(Public _pubk, bi::udp::endpoint _udp, bool _required = false): Node(_pubk, NodeIPEndpoint(_udp), _required) {}
virtual NodeId const& address() const { return id; }
virtual Public const& publicKey() const { return id; }
NodeId id;
NodeDefaultEndpoint endpoint;
/// Endpoints by which we expect to reach node.
NodeIPEndpoint endpoint;
/// If true, node will not be removed from Node list.
bool required = false;
};
/**
* NodeEntry
* @brief Entry in Node Table
*/
struct NodeEntry: public Node
{
NodeEntry(Node _src, Public _pubk, NodeDefaultEndpoint _gw); //: Node(_pubk, _gw), distance(dist(_src.id,_pubk)) {}
NodeEntry(Node _src, Public _pubk, bi::udp::endpoint _udp); //: Node(_pubk, NodeDefaultEndpoint(_udp)), distance(dist(_src.id,_pubk)) {}
NodeEntry(Node _src, Public _pubk, NodeIPEndpoint _gw); //: Node(_pubk, _gw), distance(dist(_src.id,_pubk)) {}
NodeEntry(Node _src, Public _pubk, bi::udp::endpoint _udp); //: Node(_pubk, NodeIPEndpoint(_udp)), distance(dist(_src.id,_pubk)) {}
const unsigned distance; ///< Node's distance from _src (see constructor).
};
@ -131,9 +139,12 @@ public:
static unsigned dist(NodeId const& _a, NodeId const& _b) { u512 d = _a ^ _b; unsigned ret; for (ret = 0; d >>= 1; ++ret) {}; return ret; }
/// Add node details and attempt adding to node table if node responds to ping. NodeEntry will immediately be returned and may be used for required connectivity.
/// Add node. Node will be pinged if it's not already known.
std::shared_ptr<NodeEntry> addNode(Public const& _pubk, bi::udp::endpoint const& _udp, bi::tcp::endpoint const& _tcp = bi::tcp::endpoint());
/// Add node. Node will be pinged if it's not already known.
std::shared_ptr<NodeEntry> addNode(Node const& _node);
void join();
NodeEntry root() const { return NodeEntry(m_node, m_node.publicKey(), m_node.endpoint.udp); }
@ -142,7 +153,6 @@ public:
NodeEntry operator[](NodeId _id);
protected:
struct NodeBucket
{
@ -195,10 +205,10 @@ protected:
Secret m_secret; ///< This nodes secret key.
mutable Mutex x_nodes; ///< Mutable for thread-safe copy in nodes() const.
std::map<NodeId, std::shared_ptr<NodeEntry>> m_nodes; ///< NodeId -> Node table
std::map<NodeId, std::shared_ptr<NodeEntry>> m_nodes; ///< Nodes
mutable Mutex x_state;
std::array<NodeBucket, s_bins> m_state; ///< State table of binned nodes.
std::array<NodeBucket, s_bins> m_state; ///< State of p2p node network.
Mutex x_evictions;
std::deque<EvictionTimeout> m_evictions; ///< Eviction timeouts.

28
libp2p/Session.cpp
View File

@ -48,7 +48,7 @@ Session::Session(Host* _s, bi::tcp::socket _socket, std::shared_ptr<NodeInfo> co
Session::~Session()
{
// TODO P2P: revisit (refactored from previous logic)
// TODO: P2P revisit (refactored from previous logic)
if (m_node && !(id() && !isPermanentProblem(m_node->lastDisconnect) && !m_node->dead))
m_node->lastConnected = m_node->lastAttempted - chrono::seconds(1);
@ -87,7 +87,7 @@ int Session::rating() const
return m_node->rating;
}
// TODO P2P: integration: session->? should be unavailable when socket isn't open
// TODO: P2P integration: session->? should be unavailable when socket isn't open
bi::tcp::endpoint Session::endpoint() const
{
if (m_socket.is_open() && m_node)
@ -117,7 +117,7 @@ template <class T> vector<T> randomSelection(vector<T> const& _t, unsigned _n)
return ret;
}
// TODO P2P: integration: replace w/asio post -> serviceNodesRequest()
// TODO: P2P integration: replace w/asio post -> serviceNodesRequest()
void Session::ensureNodesRequested()
{
if (isOpen() && !m_weRequestedNodes)
@ -133,7 +133,9 @@ void Session::serviceNodesRequest()
if (!m_theyRequestedNodes)
return;
auto peers = m_server->potentialPeers(m_knownNodes);
// TODO: P2P
// auto peers = m_server->potentialPeers(m_knownNodes);
Nodes peers;
if (peers.empty())
{
addNote("peers", "requested");
@ -210,14 +212,16 @@ bool Session::interpret(RLP const& _r)
return true;
}
// TODO P2P: first pass, implement signatures. if signature fails, drop connection. if egress, flag node's endpoint as stale.
// TODO P2P: remove oldid
// TODO P2P: with encrypted transport the handshake will fail and we won't get here
m_node = m_server->noteNode(id, bi::tcp::endpoint(m_socket.remote_endpoint().address(), listenPort), m_node->id);
// TODO: P2P first pass, implement signatures. if signature fails, drop connection. if egress, flag node's endpoint as stale.
// Discussion: Most this to Host so we consolidate authentication logic and eschew peer deduplication logic.
// TODO: P2P Move all node-lifecycle information into Host. Determine best way to handle peer-lifecycle properties vs node lifecycle.
// TODO: P2P remove oldid
// TODO: P2P with encrypted transport the handshake will fail and we won't get here
// m_node = m_server->noteNode(m_node->id, bi::tcp::endpoint(m_socket.remote_endpoint().address(), listenPort));
if (m_node->isOffline())
m_node->lastConnected = chrono::system_clock::now();
// TODO P2P: introduce map of nodes we've given to this node (if GetPeers/Peers stays in TCP)
//
// // TODO: P2P introduce map of nodes we've given to this node (if GetPeers/Peers stays in TCP)
m_knownNodes.extendAll(m_node->index);
m_knownNodes.unionWith(m_node->index);
@ -334,7 +338,9 @@ bool Session::interpret(RLP const& _r)
// OK passed all our checks. Assume it's good.
addRating(1000);
m_server->noteNode(id, ep);
// TODO: P2P change to addNode()
// m_server->noteNode(id, ep);
clogS(NetTriviaDetail) << "New peer: " << ep << "(" << id .abridged()<< ")";
CONTINUE:;
}

Write Preview
Loading…
Cancel
Save