ad49c256c3
Split up util.cpp/h into: - string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach) - money utilities (parsesmoney, formatmoney) - time utilities (gettime*, sleep, format date): - and the rest (logging, argument parsing, config file parsing) The latter is basically the environment and OS handling, and is stripped of all utility functions, so we may want to rename it to something else than util.cpp/h for clarity (Matt suggested osinterface). Breaks dependency of sha256.cpp on all the things pulled in by util.
619 lines
17 KiB
C++
619 lines
17 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2014 The Bitcoin developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#ifndef BITCOIN_NET_H
|
|
#define BITCOIN_NET_H
|
|
|
|
#include "bloom.h"
|
|
#include "compat.h"
|
|
#include "hash.h"
|
|
#include "limitedmap.h"
|
|
#include "mruset.h"
|
|
#include "netbase.h"
|
|
#include "protocol.h"
|
|
#include "random.h"
|
|
#include "sync.h"
|
|
#include "uint256.h"
|
|
#include "utilstrencodings.h"
|
|
|
|
#include <deque>
|
|
#include <stdint.h>
|
|
|
|
#ifndef WIN32
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
|
|
#include <boost/filesystem/path.hpp>
|
|
#include <boost/foreach.hpp>
|
|
#include <boost/signals2/signal.hpp>
|
|
|
|
class CAddrMan;
|
|
class CBlockIndex;
|
|
class CNode;
|
|
|
|
namespace boost {
|
|
class thread_group;
|
|
} // namespace boost
|
|
|
|
/** Time between pings automatically sent out for latency probing and keepalive (in seconds). */
|
|
static const int PING_INTERVAL = 2 * 60;
|
|
/** Time after which to disconnect, after waiting for a ping response (or inactivity). */
|
|
static const int TIMEOUT_INTERVAL = 20 * 60;
|
|
/** The maximum number of entries in an 'inv' protocol message */
|
|
static const unsigned int MAX_INV_SZ = 50000;
|
|
/** -listen default */
|
|
static const bool DEFAULT_LISTEN = true;
|
|
/** -upnp default */
|
|
#ifdef USE_UPNP
|
|
static const bool DEFAULT_UPNP = USE_UPNP;
|
|
#else
|
|
static const bool DEFAULT_UPNP = false;
|
|
#endif
|
|
|
|
unsigned int ReceiveFloodSize();
|
|
unsigned int SendBufferSize();
|
|
|
|
void AddOneShot(std::string strDest);
|
|
bool RecvLine(SOCKET hSocket, std::string& strLine);
|
|
bool GetMyExternalIP(CNetAddr& ipRet);
|
|
void AddressCurrentlyConnected(const CService& addr);
|
|
CNode* FindNode(const CNetAddr& ip);
|
|
CNode* FindNode(const std::string& addrName);
|
|
CNode* FindNode(const CService& ip);
|
|
CNode* ConnectNode(CAddress addrConnect, const char *pszDest = NULL);
|
|
bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound = NULL, const char *strDest = NULL, bool fOneShot = false);
|
|
void MapPort(bool fUseUPnP);
|
|
unsigned short GetListenPort();
|
|
bool BindListenPort(const CService &bindAddr, std::string& strError, bool fWhitelisted = false);
|
|
void StartNode(boost::thread_group& threadGroup);
|
|
bool StopNode();
|
|
void SocketSendData(CNode *pnode);
|
|
|
|
typedef int NodeId;
|
|
|
|
// Signals for message handling
|
|
struct CNodeSignals
|
|
{
|
|
boost::signals2::signal<int ()> GetHeight;
|
|
boost::signals2::signal<bool (CNode*)> ProcessMessages;
|
|
boost::signals2::signal<bool (CNode*, bool)> SendMessages;
|
|
boost::signals2::signal<void (NodeId, const CNode*)> InitializeNode;
|
|
boost::signals2::signal<void (NodeId)> FinalizeNode;
|
|
};
|
|
|
|
|
|
CNodeSignals& GetNodeSignals();
|
|
|
|
|
|
enum
|
|
{
|
|
LOCAL_NONE, // unknown
|
|
LOCAL_IF, // address a local interface listens on
|
|
LOCAL_BIND, // address explicit bound to
|
|
LOCAL_UPNP, // address reported by UPnP
|
|
LOCAL_HTTP, // address reported by whatismyip.com and similar
|
|
LOCAL_MANUAL, // address explicitly specified (-externalip=)
|
|
|
|
LOCAL_MAX
|
|
};
|
|
|
|
void SetLimited(enum Network net, bool fLimited = true);
|
|
bool IsLimited(enum Network net);
|
|
bool IsLimited(const CNetAddr& addr);
|
|
bool AddLocal(const CService& addr, int nScore = LOCAL_NONE);
|
|
bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE);
|
|
bool SeenLocal(const CService& addr);
|
|
bool IsLocal(const CService& addr);
|
|
bool GetLocal(CService &addr, const CNetAddr *paddrPeer = NULL);
|
|
bool IsReachable(enum Network net);
|
|
bool IsReachable(const CNetAddr &addr);
|
|
void SetReachable(enum Network net, bool fFlag = true);
|
|
CAddress GetLocalAddress(const CNetAddr *paddrPeer = NULL);
|
|
|
|
|
|
extern bool fDiscover;
|
|
extern bool fListen;
|
|
extern uint64_t nLocalServices;
|
|
extern uint64_t nLocalHostNonce;
|
|
extern CAddrMan addrman;
|
|
extern int nMaxConnections;
|
|
|
|
extern std::vector<CNode*> vNodes;
|
|
extern CCriticalSection cs_vNodes;
|
|
extern std::map<CInv, CDataStream> mapRelay;
|
|
extern std::deque<std::pair<int64_t, CInv> > vRelayExpiration;
|
|
extern CCriticalSection cs_mapRelay;
|
|
extern limitedmap<CInv, int64_t> mapAlreadyAskedFor;
|
|
|
|
extern std::vector<std::string> vAddedNodes;
|
|
extern CCriticalSection cs_vAddedNodes;
|
|
|
|
extern NodeId nLastNodeId;
|
|
extern CCriticalSection cs_nLastNodeId;
|
|
|
|
struct LocalServiceInfo {
|
|
int nScore;
|
|
int nPort;
|
|
};
|
|
|
|
extern CCriticalSection cs_mapLocalHost;
|
|
extern std::map<CNetAddr, LocalServiceInfo> mapLocalHost;
|
|
|
|
class CNodeStats
|
|
{
|
|
public:
|
|
NodeId nodeid;
|
|
uint64_t nServices;
|
|
int64_t nLastSend;
|
|
int64_t nLastRecv;
|
|
int64_t nTimeConnected;
|
|
std::string addrName;
|
|
int nVersion;
|
|
std::string cleanSubVer;
|
|
bool fInbound;
|
|
int nStartingHeight;
|
|
uint64_t nSendBytes;
|
|
uint64_t nRecvBytes;
|
|
bool fSyncNode;
|
|
bool fWhitelisted;
|
|
double dPingTime;
|
|
double dPingWait;
|
|
std::string addrLocal;
|
|
};
|
|
|
|
|
|
|
|
|
|
class CNetMessage {
|
|
public:
|
|
bool in_data; // parsing header (false) or data (true)
|
|
|
|
CDataStream hdrbuf; // partially received header
|
|
CMessageHeader hdr; // complete header
|
|
unsigned int nHdrPos;
|
|
|
|
CDataStream vRecv; // received message data
|
|
unsigned int nDataPos;
|
|
|
|
int64_t nTime; // time (in microseconds) of message receipt.
|
|
|
|
CNetMessage(int nTypeIn, int nVersionIn) : hdrbuf(nTypeIn, nVersionIn), vRecv(nTypeIn, nVersionIn) {
|
|
hdrbuf.resize(24);
|
|
in_data = false;
|
|
nHdrPos = 0;
|
|
nDataPos = 0;
|
|
nTime = 0;
|
|
}
|
|
|
|
bool complete() const
|
|
{
|
|
if (!in_data)
|
|
return false;
|
|
return (hdr.nMessageSize == nDataPos);
|
|
}
|
|
|
|
void SetVersion(int nVersionIn)
|
|
{
|
|
hdrbuf.SetVersion(nVersionIn);
|
|
vRecv.SetVersion(nVersionIn);
|
|
}
|
|
|
|
int readHeader(const char *pch, unsigned int nBytes);
|
|
int readData(const char *pch, unsigned int nBytes);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/** Information about a peer */
|
|
class CNode
|
|
{
|
|
public:
|
|
// socket
|
|
uint64_t nServices;
|
|
SOCKET hSocket;
|
|
CDataStream ssSend;
|
|
size_t nSendSize; // total size of all vSendMsg entries
|
|
size_t nSendOffset; // offset inside the first vSendMsg already sent
|
|
uint64_t nSendBytes;
|
|
std::deque<CSerializeData> vSendMsg;
|
|
CCriticalSection cs_vSend;
|
|
|
|
std::deque<CInv> vRecvGetData;
|
|
std::deque<CNetMessage> vRecvMsg;
|
|
CCriticalSection cs_vRecvMsg;
|
|
uint64_t nRecvBytes;
|
|
int nRecvVersion;
|
|
|
|
int64_t nLastSend;
|
|
int64_t nLastRecv;
|
|
int64_t nTimeConnected;
|
|
CAddress addr;
|
|
std::string addrName;
|
|
CService addrLocal;
|
|
int nVersion;
|
|
// strSubVer is whatever byte array we read from the wire. However, this field is intended
|
|
// to be printed out, displayed to humans in various forms and so on. So we sanitize it and
|
|
// store the sanitized version in cleanSubVer. The original should be used when dealing with
|
|
// the network or wire types and the cleaned string used when displayed or logged.
|
|
std::string strSubVer, cleanSubVer;
|
|
bool fWhitelisted; // This peer can bypass DoS banning.
|
|
bool fOneShot;
|
|
bool fClient;
|
|
bool fInbound;
|
|
bool fNetworkNode;
|
|
bool fSuccessfullyConnected;
|
|
bool fDisconnect;
|
|
// We use fRelayTxes for two purposes -
|
|
// a) it allows us to not relay tx invs before receiving the peer's version message
|
|
// b) the peer may tell us in their version message that we should not relay tx invs
|
|
// until they have initialized their bloom filter.
|
|
bool fRelayTxes;
|
|
CSemaphoreGrant grantOutbound;
|
|
CCriticalSection cs_filter;
|
|
CBloomFilter* pfilter;
|
|
int nRefCount;
|
|
NodeId id;
|
|
protected:
|
|
|
|
// Denial-of-service detection/prevention
|
|
// Key is IP address, value is banned-until-time
|
|
static std::map<CNetAddr, int64_t> setBanned;
|
|
static CCriticalSection cs_setBanned;
|
|
|
|
// Whitelisted ranges. Any node connecting from these is automatically
|
|
// whitelisted (as well as those connecting to whitelisted binds).
|
|
static std::vector<CSubNet> vWhitelistedRange;
|
|
static CCriticalSection cs_vWhitelistedRange;
|
|
|
|
// Basic fuzz-testing
|
|
void Fuzz(int nChance); // modifies ssSend
|
|
|
|
public:
|
|
uint256 hashContinue;
|
|
CBlockIndex* pindexLastGetBlocksBegin;
|
|
uint256 hashLastGetBlocksEnd;
|
|
int nStartingHeight;
|
|
bool fStartSync;
|
|
|
|
// flood relay
|
|
std::vector<CAddress> vAddrToSend;
|
|
mruset<CAddress> setAddrKnown;
|
|
bool fGetAddr;
|
|
std::set<uint256> setKnown;
|
|
|
|
// inventory based relay
|
|
mruset<CInv> setInventoryKnown;
|
|
std::vector<CInv> vInventoryToSend;
|
|
CCriticalSection cs_inventory;
|
|
std::multimap<int64_t, CInv> mapAskFor;
|
|
|
|
// Ping time measurement:
|
|
// The pong reply we're expecting, or 0 if no pong expected.
|
|
uint64_t nPingNonceSent;
|
|
// Time (in usec) the last ping was sent, or 0 if no ping was ever sent.
|
|
int64_t nPingUsecStart;
|
|
// Last measured round-trip time.
|
|
int64_t nPingUsecTime;
|
|
// Whether a ping is requested.
|
|
bool fPingQueued;
|
|
|
|
CNode(SOCKET hSocketIn, CAddress addrIn, std::string addrNameIn = "", bool fInboundIn=false);
|
|
~CNode();
|
|
|
|
private:
|
|
// Network usage totals
|
|
static CCriticalSection cs_totalBytesRecv;
|
|
static CCriticalSection cs_totalBytesSent;
|
|
static uint64_t nTotalBytesRecv;
|
|
static uint64_t nTotalBytesSent;
|
|
|
|
CNode(const CNode&);
|
|
void operator=(const CNode&);
|
|
|
|
public:
|
|
|
|
NodeId GetId() const {
|
|
return id;
|
|
}
|
|
|
|
int GetRefCount()
|
|
{
|
|
assert(nRefCount >= 0);
|
|
return nRefCount;
|
|
}
|
|
|
|
// requires LOCK(cs_vRecvMsg)
|
|
unsigned int GetTotalRecvSize()
|
|
{
|
|
unsigned int total = 0;
|
|
BOOST_FOREACH(const CNetMessage &msg, vRecvMsg)
|
|
total += msg.vRecv.size() + 24;
|
|
return total;
|
|
}
|
|
|
|
// requires LOCK(cs_vRecvMsg)
|
|
bool ReceiveMsgBytes(const char *pch, unsigned int nBytes);
|
|
|
|
// requires LOCK(cs_vRecvMsg)
|
|
void SetRecvVersion(int nVersionIn)
|
|
{
|
|
nRecvVersion = nVersionIn;
|
|
BOOST_FOREACH(CNetMessage &msg, vRecvMsg)
|
|
msg.SetVersion(nVersionIn);
|
|
}
|
|
|
|
CNode* AddRef()
|
|
{
|
|
nRefCount++;
|
|
return this;
|
|
}
|
|
|
|
void Release()
|
|
{
|
|
nRefCount--;
|
|
}
|
|
|
|
|
|
|
|
void AddAddressKnown(const CAddress& addr)
|
|
{
|
|
setAddrKnown.insert(addr);
|
|
}
|
|
|
|
void PushAddress(const CAddress& addr)
|
|
{
|
|
// Known checking here is only to save space from duplicates.
|
|
// SendMessages will filter it again for knowns that were added
|
|
// after addresses were pushed.
|
|
if (addr.IsValid() && !setAddrKnown.count(addr))
|
|
vAddrToSend.push_back(addr);
|
|
}
|
|
|
|
|
|
void AddInventoryKnown(const CInv& inv)
|
|
{
|
|
{
|
|
LOCK(cs_inventory);
|
|
setInventoryKnown.insert(inv);
|
|
}
|
|
}
|
|
|
|
void PushInventory(const CInv& inv)
|
|
{
|
|
{
|
|
LOCK(cs_inventory);
|
|
if (!setInventoryKnown.count(inv))
|
|
vInventoryToSend.push_back(inv);
|
|
}
|
|
}
|
|
|
|
void AskFor(const CInv& inv);
|
|
|
|
// TODO: Document the postcondition of this function. Is cs_vSend locked?
|
|
void BeginMessage(const char* pszCommand) EXCLUSIVE_LOCK_FUNCTION(cs_vSend);
|
|
|
|
// TODO: Document the precondition of this function. Is cs_vSend locked?
|
|
void AbortMessage() UNLOCK_FUNCTION(cs_vSend);
|
|
|
|
// TODO: Document the precondition of this function. Is cs_vSend locked?
|
|
void EndMessage() UNLOCK_FUNCTION(cs_vSend);
|
|
|
|
void PushVersion();
|
|
|
|
|
|
void PushMessage(const char* pszCommand)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1>
|
|
void PushMessage(const char* pszCommand, const T1& a1)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
void PushMessage(const char* pszCommand, const T1& a1, const T2& a2)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1 << a2;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3>
|
|
void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1 << a2 << a3;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4>
|
|
void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1 << a2 << a3 << a4;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
|
void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1 << a2 << a3 << a4 << a5;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
|
|
void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1 << a2 << a3 << a4 << a5 << a6;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
|
void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
|
|
void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
|
|
void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8, const T9& a9)
|
|
{
|
|
try
|
|
{
|
|
BeginMessage(pszCommand);
|
|
ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8 << a9;
|
|
EndMessage();
|
|
}
|
|
catch (...)
|
|
{
|
|
AbortMessage();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
bool IsSubscribed(unsigned int nChannel);
|
|
void Subscribe(unsigned int nChannel, unsigned int nHops=0);
|
|
void CancelSubscribe(unsigned int nChannel);
|
|
void CloseSocketDisconnect();
|
|
|
|
// Denial-of-service detection/prevention
|
|
// The idea is to detect peers that are behaving
|
|
// badly and disconnect/ban them, but do it in a
|
|
// one-coding-mistake-won't-shatter-the-entire-network
|
|
// way.
|
|
// IMPORTANT: There should be nothing I can give a
|
|
// node that it will forward on that will make that
|
|
// node's peers drop it. If there is, an attacker
|
|
// can isolate a node and/or try to split the network.
|
|
// Dropping a node for sending stuff that is invalid
|
|
// now but might be valid in a later version is also
|
|
// dangerous, because it can cause a network split
|
|
// between nodes running old code and nodes running
|
|
// new code.
|
|
static void ClearBanned(); // needed for unit testing
|
|
static bool IsBanned(CNetAddr ip);
|
|
static bool Ban(const CNetAddr &ip);
|
|
void copyStats(CNodeStats &stats);
|
|
|
|
static bool IsWhitelistedRange(const CNetAddr &ip);
|
|
static void AddWhitelistedRange(const CSubNet &subnet);
|
|
|
|
// Network stats
|
|
static void RecordBytesRecv(uint64_t bytes);
|
|
static void RecordBytesSent(uint64_t bytes);
|
|
|
|
static uint64_t GetTotalBytesRecv();
|
|
static uint64_t GetTotalBytesSent();
|
|
};
|
|
|
|
|
|
|
|
class CTransaction;
|
|
void RelayTransaction(const CTransaction& tx);
|
|
void RelayTransaction(const CTransaction& tx, const CDataStream& ss);
|
|
|
|
/** Access to the (IP) address database (peers.dat) */
|
|
class CAddrDB
|
|
{
|
|
private:
|
|
boost::filesystem::path pathAddr;
|
|
public:
|
|
CAddrDB();
|
|
bool Write(const CAddrMan& addr);
|
|
bool Read(CAddrMan& addr);
|
|
};
|
|
|
|
#endif
|