Common.h

Go to the documentation of this file.

// Aleth: Ethereum C++ client, tools and libraries.
// Copyright 2014-2019 Aleth Authors.
// Licensed under the GNU General Public License, Version 3.
 
//
// Miscellanea required for the Host/Session/NodeTable classes.
//
 
#pragma once
 
#include <atomic>
#include <set>
#include <shared_mutex>
#include <string>
#include <vector>
 
// Make sure boost/asio.hpp is included before windows.h.
#include <libdevcore/Exceptions.h>
#include <libdevcore/Guards.h>
#include <libdevcore/Log.h>
#include <libdevcore/RLP.h>
#include <libdevcrypto/Common.h>
 
#include <boost/asio.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/steady_timer.hpp>
#include <chrono>
 
namespace ba = boost::asio;
namespace bi = ba::ip;
 
namespace dev {
 
class RLP;
class RLPStream;
 
namespace p2p {
 
constexpr unsigned c_protocolVersion = 1029;
 
class NodeIPEndpoint;
class Node;
extern const NodeIPEndpoint UnspecifiedNodeIPEndpoint;
extern const Node UnspecifiedNode;
 
using NodeID = h512;
 
bool isPrivateAddress(bi::address const& _addressToCheck);
bool isPrivateAddress(std::string const& _addressToCheck);
bool isLocalHostAddress(bi::address const& _addressToCheck);
bool isLocalHostAddress(std::string const& _addressToCheck);
bool isPublicAddress(bi::address const& _addressToCheck);
bool isPublicAddress(std::string const& _addressToCheck);
bool isAllowedAddress(bool _allowLocalDiscovery, bi::address const& _addressToCheck);
bool isAllowedEndpoint(bool _allowLocalDiscovery, NodeIPEndpoint const& _endpointToCheck);
 
class UPnP;
struct Host;
struct Session;
 
struct NetworkStartRequired : virtual dev::Exception {};
struct InvalidPublicIPAddress : virtual dev::Exception {};
struct NetworkRestartNotSupported : virtual dev::Exception {};
 
struct ECDHEError : virtual Exception {};
 
#define NET_GLOBAL_LOGGER(NAME, SEVERITY)                                  \
  BOOST_LOG_INLINE_GLOBAL_LOGGER_CTOR_ARGS(                                \
      g_##NAME##Logger, boost::log::sources::severity_channel_logger_mt<>, \
      (boost::log::keywords::severity = SEVERITY)(boost::log::keywords::channel = "net"))
 
NET_GLOBAL_LOGGER(netnote, VerbosityInfo)
#define cnetnote LOG(dev::p2p::g_netnoteLogger::get())
NET_GLOBAL_LOGGER(netlog, VerbosityDebug)
#define cnetlog LOG(dev::p2p::g_netlogLogger::get())
NET_GLOBAL_LOGGER(netdetails, VerbosityTrace)
#define cnetdetails LOG(dev::p2p::g_netdetailsLogger::get())
 
enum P2pPacketType { HelloPacket = 0, DisconnectPacket, PingPacket, PongPacket, UserPacket = 0x10 };
 
char const* p2pPacketTypeToString(P2pPacketType _packetType);
 
enum DisconnectReason {
  DisconnectRequested = 0,
  TCPError,
  BadProtocol,
  UselessPeer,
  TooManyPeers,
  DuplicatePeer,
  IncompatibleProtocol,
  NullIdentity,
  ClientQuit,
  UnexpectedIdentity,
  LocalIdentity,
  PingTimeout,
  UserReason = 0x10,
  NoDisconnect = 0xffff
};
 
std::string reasonOf(DisconnectReason _r);
 
enum class HandshakeFailureReason {
  NoFailure = 0,
  UnknownFailure,
  Timeout,
  TCPError,
  FrameDecryptionFailure,
  InternalError,
  ProtocolError,
  DisconnectRequested
};
 
using CapDesc = std::pair<std::string, unsigned>;
using CapDescs = std::vector<CapDesc>;
 
/*
 * Used by Host to pass negotiated information about a connection to a
 * new Peer Session; PeerSessionInfo is then maintained by Session and can
 * be queried for point-in-time status information via Host.
 */
struct PeerSessionInfo {
  NodeID id;
  std::string clientVersion;
  std::string host;
  unsigned short port;
  std::chrono::steady_clock::duration lastPing;
  std::set<CapDesc> caps;
};
 
using PeerSessionInfos = std::vector<PeerSessionInfo>;
 
enum class PeerType { Optional, Required };
 
class NodeIPEndpoint {
 public:
  enum RLPAppend { StreamList, StreamInline };
 
  NodeIPEndpoint() = default;
  NodeIPEndpoint(bi::address _addr, uint16_t _udp, uint16_t _tcp)
      : m_address(std::move(_addr)), m_udpPort(_udp), m_tcpPort(_tcp) {}
  explicit NodeIPEndpoint(RLP const& _r) { interpretRLP(_r); }
 
  operator bi::udp::endpoint() const { return {m_address, m_udpPort}; }
  operator bi::tcp::endpoint() const { return {m_address, m_tcpPort}; }
 
  explicit operator bool() const { return !m_address.is_unspecified() && m_udpPort > 0 && m_tcpPort > 0; }
 
  bool operator==(NodeIPEndpoint const& _cmp) const {
    return m_address == _cmp.m_address && m_udpPort == _cmp.m_udpPort && m_tcpPort == _cmp.m_tcpPort;
  }
  bool operator!=(NodeIPEndpoint const& _cmp) const { return !operator==(_cmp); }
 
  void streamRLP(RLPStream& _s, RLPAppend _append = StreamList) const;
  void interpretRLP(RLP const& _r);
 
  bi::address address() const { return m_address; }
 
  void setAddress(bi::address _addr) { m_address = std::move(_addr); }
 
  uint16_t udpPort() const { return m_udpPort; }
 
  void setUdpPort(uint16_t _udp) { m_udpPort = _udp; }
 
  uint16_t tcpPort() const { return m_tcpPort; }
 
  void setTcpPort(uint16_t _tcp) { m_tcpPort = _tcp; }
 
 private:
  bi::address m_address;
  uint16_t m_udpPort = 0;
  uint16_t m_tcpPort = 0;
};
 
struct NodeSpec {
  NodeSpec() {}
 
  NodeSpec(std::string const& _user);
 
  NodeSpec(std::string const& _addr, uint16_t _port, int _udpPort = -1)
      : m_address(_addr), m_tcpPort(_port), m_udpPort(_udpPort == -1 ? _port : (uint16_t)_udpPort) {}
 
  NodeID id() const { return m_id; }
 
  NodeIPEndpoint nodeIPEndpoint() const;
 
  std::string enode() const;
 
  bool isValid() const;
 
 private:
  std::string m_address;
  uint16_t m_tcpPort = 0;
  uint16_t m_udpPort = 0;
  NodeID m_id;
};
 
class Node {
 public:
  virtual ~Node() = default;
  Node(Node const&);
  Node(Public _publicKey, NodeIPEndpoint const& _ip, PeerType _peerType = PeerType::Optional)
      : id(_publicKey), endpoint_(_ip), peerType(_peerType) {}
  Node(NodeSpec const& _s, PeerType _peerType = PeerType::Optional);
 
  NodeID const& address() const { return id; }
 
  NodeIPEndpoint get_endpoint() const;
  void set_endpoint(NodeIPEndpoint endpoint);
 
  explicit operator bool() const { return static_cast<bool>(id); }
 
  // TODO: make private, give accessors and rename m_...
  NodeID const id;
 
 private:
  NodeIPEndpoint endpoint_;
  mutable std::shared_mutex endpoint_mu_;
 
 public:
  // TODO: p2p implement
  std::atomic<PeerType> peerType{PeerType::Optional};
  std::atomic<uint16_t> external_udp_port;
};
 
inline boost::log::formatting_ostream& operator<<(boost::log::formatting_ostream& _strm, Node const& _node) {
  return _strm << _node.id << '@' << _node.get_endpoint();
}
 
inline boost::log::formatting_ostream& operator<<(boost::log::formatting_ostream& _strm, Node& _node) {
  auto const& constValue = _node;
  _strm << constValue;
  return _strm;
}
 
inline std::ostream& operator<<(std::ostream& _strm, NodeID const& _id) {
  _strm << "##" << _id.abridged();
  return _strm;
}
 
inline boost::log::formatting_ostream& operator<<(boost::log::formatting_ostream& _strm,
                                                  PeerSessionInfo const& _peerSessionInfo) {
  _strm << _peerSessionInfo.id << "|" << _peerSessionInfo.clientVersion << "|" << _peerSessionInfo.host << "|"
        << _peerSessionInfo.port << "|";
  for (auto const& cap : _peerSessionInfo.caps) _strm << "(" << cap.first << "," << cap.second << ")";
  return _strm;
}
 
std::ostream& operator<<(std::ostream& _out, NodeIPEndpoint const& _ep);
}  // namespace p2p
}  // namespace dev
 
#if !defined(BOOST_ASIO_HAS_STD_HASH)
namespace std {
template <>
struct hash<bi::address> {
  size_t operator()(bi::address const& _a) const {
    if (_a.is_v4()) return std::hash<unsigned long>()(_a.to_v4().to_ulong());
    if (_a.is_v6()) {
      auto const& range = _a.to_v6().to_bytes();
      return boost::hash_range(range.begin(), range.end());
    }
    if (_a.is_unspecified())
      return static_cast<size_t>(0x3487194039229152ull);  // Chosen by fair dice roll, guaranteed to be
                                                          // random
    return std::hash<std::string>()(_a.to_string());
  }
};
}  // namespace std
#endif  // !defined(BOOST_ASIO_HAS_STD_HASH)