Hush Full Node software. We were censored from Github, this is where all development happens now.
https://hush.is
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
243 lines
7.0 KiB
243 lines
7.0 KiB
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
|
// Copyright (c) 2016-2024 The Hush developers
|
|
// Distributed under the GPLv3 software license, see the accompanying
|
|
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
|
|
/******************************************************************************
|
|
* Copyright © 2014-2019 The SuperNET Developers. *
|
|
* *
|
|
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
|
|
* the top-level directory of this distribution for the individual copyright *
|
|
* holder information and the developer policies on copyright and licensing. *
|
|
* *
|
|
* Unless otherwise agreed in a custom licensing agreement, no part of the *
|
|
* SuperNET software, including this file may be copied, modified, propagated *
|
|
* or distributed except according to the terms contained in the LICENSE file *
|
|
* *
|
|
* Removal or modification of this copyright notice is prohibited. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
#include "main.h"
|
|
#include "protocol.h"
|
|
|
|
#include "util.h"
|
|
#include "util/strencodings.h"
|
|
|
|
#ifndef _WIN32
|
|
# include <arpa/inet.h>
|
|
#endif
|
|
|
|
static const char* ppszTypeName[] =
|
|
{
|
|
"ERROR",
|
|
"tx",
|
|
"block",
|
|
"filtered block"
|
|
};
|
|
|
|
namespace NetMsgType {
|
|
const char *VERSION="version"; //used
|
|
const char *VERACK="verack"; //used
|
|
const char *ADDR="addr"; //used
|
|
const char *ADDRV2="addrv2"; //used
|
|
const char *SENDADDRV2="sendaddrv2";
|
|
const char *INV="inv"; //used
|
|
const char *GETDATA="getdata"; //used
|
|
const char *MERKLEBLOCK="merkleblock";
|
|
const char *GETBLOCKS="getblocks"; //used
|
|
const char *GETHEADERS="getheaders"; //used
|
|
const char *TX="tx"; //used
|
|
const char *HEADERS="headers"; //used
|
|
const char *BLOCK="block"; //used
|
|
const char *GETADDR="getaddr"; //used
|
|
const char *PING="ping"; //used
|
|
const char *PONG="pong"; //used
|
|
const char *NOTFOUND="notfound"; //used
|
|
const char *FILTERLOAD="filterload"; //used
|
|
const char *FILTERADD="filteradd"; //used
|
|
const char *FILTERCLEAR="filterclear"; //used
|
|
const char *SENDHEADERS="sendheaders";
|
|
const char *FEEFILTER="feefilter";
|
|
const char *SENDCMPCT="sendcmpct";
|
|
const char *CMPCTBLOCK="cmpctblock";
|
|
const char *GETBLOCKTXN="getblocktxn";
|
|
const char *BLOCKTXN="blocktxn";
|
|
const char *GETCFILTERS="getcfilters";
|
|
const char *CFILTER="cfilter";
|
|
const char *GETCFHEADERS="getcfheaders";
|
|
const char *CFHEADERS="cfheaders";
|
|
const char *GETCFCHECKPT="getcfcheckpt";
|
|
const char *CFCHECKPT="cfcheckpt";
|
|
const char *WTXIDRELAY="wtxidrelay";
|
|
const char *EVENTS="events"; //used
|
|
const char *GETNSPV="getnSPV"; //used
|
|
const char *NSPV="nSPV"; //used
|
|
const char *ALERT="alert"; //used
|
|
const char *REJECT="reject"; //used
|
|
} // namespace NetMsgType
|
|
|
|
/** All known message types. Keep this in the same order as the list of
|
|
* messages above and in protocol.h.
|
|
*/
|
|
const static std::string allNetMessageTypes[] = {
|
|
NetMsgType::VERSION,
|
|
NetMsgType::VERACK,
|
|
NetMsgType::ADDR,
|
|
NetMsgType::ADDRV2,
|
|
NetMsgType::SENDADDRV2,
|
|
NetMsgType::INV,
|
|
NetMsgType::GETDATA,
|
|
NetMsgType::MERKLEBLOCK,
|
|
NetMsgType::GETBLOCKS,
|
|
NetMsgType::GETHEADERS,
|
|
NetMsgType::TX,
|
|
NetMsgType::HEADERS,
|
|
NetMsgType::BLOCK,
|
|
NetMsgType::GETADDR,
|
|
NetMsgType::PING,
|
|
NetMsgType::PONG,
|
|
NetMsgType::NOTFOUND,
|
|
NetMsgType::FILTERLOAD,
|
|
NetMsgType::FILTERADD,
|
|
NetMsgType::FILTERCLEAR,
|
|
NetMsgType::SENDHEADERS,
|
|
NetMsgType::FEEFILTER,
|
|
NetMsgType::SENDCMPCT,
|
|
NetMsgType::CMPCTBLOCK,
|
|
NetMsgType::GETBLOCKTXN,
|
|
NetMsgType::BLOCKTXN,
|
|
NetMsgType::GETCFILTERS,
|
|
NetMsgType::CFILTER,
|
|
NetMsgType::GETCFHEADERS,
|
|
NetMsgType::CFHEADERS,
|
|
NetMsgType::GETCFCHECKPT,
|
|
NetMsgType::CFCHECKPT,
|
|
NetMsgType::WTXIDRELAY,
|
|
NetMsgType::EVENTS,
|
|
NetMsgType::GETNSPV,
|
|
NetMsgType::NSPV,
|
|
NetMsgType::ALERT,
|
|
NetMsgType::REJECT,
|
|
};
|
|
|
|
CMessageHeader::CMessageHeader(const MessageStartChars& pchMessageStartIn)
|
|
{
|
|
memcpy(pchMessageStart, pchMessageStartIn, MESSAGE_START_SIZE);
|
|
memset(pchCommand, 0, sizeof(pchCommand));
|
|
nMessageSize = -1;
|
|
nChecksum = 0;
|
|
}
|
|
|
|
CMessageHeader::CMessageHeader(const MessageStartChars& pchMessageStartIn, const char* pszCommand, unsigned int nMessageSizeIn)
|
|
{
|
|
memcpy(pchMessageStart, pchMessageStartIn, MESSAGE_START_SIZE);
|
|
memset(pchCommand, 0, sizeof(pchCommand));
|
|
strncpy(pchCommand, pszCommand, COMMAND_SIZE);
|
|
nMessageSize = nMessageSizeIn;
|
|
nChecksum = 0;
|
|
}
|
|
|
|
std::string CMessageHeader::GetCommand() const
|
|
{
|
|
return std::string(pchCommand, pchCommand + strnlen(pchCommand, COMMAND_SIZE));
|
|
}
|
|
|
|
bool CMessageHeader::IsValid(const MessageStartChars& pchMessageStartIn) const
|
|
{
|
|
// Check start string
|
|
if (memcmp(pchMessageStart, pchMessageStartIn, MESSAGE_START_SIZE) != 0)
|
|
return false;
|
|
|
|
// Check the command string for errors
|
|
for (const char* p1 = pchCommand; p1 < pchCommand + COMMAND_SIZE; p1++)
|
|
{
|
|
if (*p1 == 0)
|
|
{
|
|
// Must be all zeros after the first zero
|
|
for (; p1 < pchCommand + COMMAND_SIZE; p1++)
|
|
if (*p1 != 0)
|
|
return false;
|
|
}
|
|
else if (*p1 < ' ' || *p1 > 0x7E)
|
|
return false;
|
|
}
|
|
|
|
// Message size
|
|
if (nMessageSize > MAX_SIZE)
|
|
{
|
|
LogPrintf("CMessageHeader::IsValid(): (%s, %u bytes) nMessageSize > MAX_SIZE\n", GetCommand(), nMessageSize);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
CAddress::CAddress() : CService()
|
|
{
|
|
Init();
|
|
}
|
|
|
|
CAddress::CAddress(CService ipIn, uint64_t nServicesIn) : CService(ipIn)
|
|
{
|
|
Init();
|
|
nServices = nServicesIn;
|
|
}
|
|
|
|
void CAddress::Init()
|
|
{
|
|
nServices = GetBoolArg("-nspv_msg", DEFAULT_NSPV_PROCESSING) ? NODE_NETWORK | NODE_NSPV : NODE_NETWORK;
|
|
nTime = 100000000;
|
|
}
|
|
|
|
CInv::CInv()
|
|
{
|
|
type = 0;
|
|
hash.SetNull();
|
|
}
|
|
|
|
CInv::CInv(int typeIn, const uint256& hashIn)
|
|
{
|
|
type = typeIn;
|
|
hash = hashIn;
|
|
}
|
|
|
|
CInv::CInv(const std::string& strType, const uint256& hashIn)
|
|
{
|
|
unsigned int i;
|
|
for (i = 1; i < ARRAYLEN(ppszTypeName); i++)
|
|
{
|
|
if (strType == ppszTypeName[i])
|
|
{
|
|
type = i;
|
|
break;
|
|
}
|
|
}
|
|
if (i == ARRAYLEN(ppszTypeName))
|
|
throw std::out_of_range(strprintf("CInv::CInv(string, uint256): unknown type '%s'", strType));
|
|
hash = hashIn;
|
|
}
|
|
|
|
bool operator<(const CInv& a, const CInv& b)
|
|
{
|
|
return (a.type < b.type || (a.type == b.type && a.hash < b.hash));
|
|
}
|
|
|
|
bool CInv::IsKnownType() const
|
|
{
|
|
return (type >= 1 && type < (int)ARRAYLEN(ppszTypeName));
|
|
}
|
|
|
|
const char* CInv::GetCommand() const
|
|
{
|
|
if (!IsKnownType())
|
|
throw std::out_of_range(strprintf("CInv::GetCommand(): type=%d unknown type", type));
|
|
return ppszTypeName[type];
|
|
}
|
|
|
|
std::string CInv::ToString() const
|
|
{
|
|
return strprintf("%s %s", GetCommand(), hash.ToString());
|
|
}
|
|
|