ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-12-06 17:27:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename the protocol from newcoin to ripple.

Browse Source
This commit is contained in:
Arthur Britto
2012-10-12 15:53:59 -07:00
parent 2af15db40a
commit b2481f3c49
9 changed files with 172 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
src/LedgerAcquire.cpp
View File

@@ -194,9 +194,9 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
#endif
if (!mHaveBase)
{
newcoin::TMGetLedger tmGL;
ripple::TMGetLedger tmGL;
tmGL.set_ledgerhash(mHash.begin(), mHash.size());
tmGL.set_itype(newcoin::liBASE);
tmGL.set_itype(ripple::liBASE);
*(tmGL.add_nodeids()) = SHAMapNode().getRawString();
sendRequest(tmGL, peer);
}
@@ -209,10 +209,10 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
assert(mLedger);
if (mLedger->peekTransactionMap()->getHash().isZero())
{ // we need the root node
newcoin::TMGetLedger tmGL;
ripple::TMGetLedger tmGL;
tmGL.set_ledgerhash(mHash.begin(), mHash.size());
tmGL.set_ledgerseq(mLedger->getLedgerSeq());
tmGL.set_itype(newcoin::liTX_NODE);
tmGL.set_itype(ripple::liTX_NODE);
*(tmGL.add_nodeids()) = SHAMapNode().getRawString();
sendRequest(tmGL, peer);
}
@@ -234,10 +234,10 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
}
else
{
newcoin::TMGetLedger tmGL;
ripple::TMGetLedger tmGL;
tmGL.set_ledgerhash(mHash.begin(), mHash.size());
tmGL.set_ledgerseq(mLedger->getLedgerSeq());
tmGL.set_itype(newcoin::liTX_NODE);
tmGL.set_itype(ripple::liTX_NODE);
for (std::vector<SHAMapNode>::iterator it = nodeIDs.begin(); it != nodeIDs.end(); ++it)
*(tmGL.add_nodeids()) = it->getRawString();
sendRequest(tmGL, peer);
@@ -253,10 +253,10 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
assert(mLedger);
if (mLedger->peekAccountStateMap()->getHash().isZero())
{ // we need the root node
newcoin::TMGetLedger tmGL;
ripple::TMGetLedger tmGL;
tmGL.set_ledgerhash(mHash.begin(), mHash.size());
tmGL.set_ledgerseq(mLedger->getLedgerSeq());
tmGL.set_itype(newcoin::liAS_NODE);
tmGL.set_itype(ripple::liAS_NODE);
*(tmGL.add_nodeids()) = SHAMapNode().getRawString();
sendRequest(tmGL, peer);
}
@@ -278,10 +278,10 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
}
else
{
newcoin::TMGetLedger tmGL;
ripple::TMGetLedger tmGL;
tmGL.set_ledgerhash(mHash.begin(), mHash.size());
tmGL.set_ledgerseq(mLedger->getLedgerSeq());
tmGL.set_itype(newcoin::liAS_NODE);
tmGL.set_itype(ripple::liAS_NODE);
for (std::vector<SHAMapNode>::iterator it = nodeIDs.begin(); it != nodeIDs.end(); ++it)
*(tmGL.add_nodeids()) = it->getRawString();
sendRequest(tmGL, peer);
@@ -295,21 +295,21 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
resetTimer();
}
void PeerSet::sendRequest(const newcoin::TMGetLedger& tmGL, Peer::ref peer)
void PeerSet::sendRequest(const ripple::TMGetLedger& tmGL, Peer::ref peer)
{
if (!peer)
sendRequest(tmGL);
else
peer->sendPacket(boost::make_shared<PackedMessage>(tmGL, newcoin::mtGET_LEDGER));
peer->sendPacket(boost::make_shared<PackedMessage>(tmGL, ripple::mtGET_LEDGER));
}
void PeerSet::sendRequest(const newcoin::TMGetLedger& tmGL)
void PeerSet::sendRequest(const ripple::TMGetLedger& tmGL)
{
boost::recursive_mutex::scoped_lock sl(mLock);
if (mPeers.empty())
return;
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tmGL, newcoin::mtGET_LEDGER);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tmGL, ripple::mtGET_LEDGER);
std::vector< boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
while (it != mPeers.end())
@@ -476,7 +476,7 @@ void LedgerAcquireMaster::dropLedger(const uint256& hash)
mLedgers.erase(hash);
}
bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref peer)
bool LedgerAcquireMaster::gotLedgerData(ripple::TMLedgerData& packet, Peer::ref peer)
{
#ifdef LA_DEBUG
Log(lsTRACE) << "got data for acquiring ledger ";
@@ -495,11 +495,11 @@ bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref
LedgerAcquire::pointer ledger = find(hash);
if (!ledger) return false;
if (packet.type() == newcoin::liBASE)
if (packet.type() == ripple::liBASE)
{
if (packet.nodes_size() < 1)
return false;
const newcoin::TMLedgerNode& node = packet.nodes(0);
const ripple::TMLedgerNode& node = packet.nodes(0);
if (!ledger->takeBase(node.nodedata()))
return false;
if (packet.nodes_size() == 1)
@@ -522,7 +522,7 @@ bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref
return true;
}
if ((packet.type() == newcoin::liTX_NODE) || (packet.type() == newcoin::liAS_NODE))
if ((packet.type() == ripple::liTX_NODE) || (packet.type() == ripple::liAS_NODE))
{
std::list<SHAMapNode> nodeIDs;
std::list< std::vector<unsigned char> > nodeData;
@@ -530,14 +530,14 @@ bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref
if (packet.nodes().size() <= 0) return false;
for (int i = 0; i < packet.nodes().size(); ++i)
{
const newcoin::TMLedgerNode& node = packet.nodes(i);
const ripple::TMLedgerNode& node = packet.nodes(i);
if (!node.has_nodeid() || !node.has_nodedata()) return false;
nodeIDs.push_back(SHAMapNode(node.nodeid().data(), node.nodeid().size()));
nodeData.push_back(std::vector<unsigned char>(node.nodedata().begin(), node.nodedata().end()));
}
bool ret;
if (packet.type() == newcoin::liTX_NODE)
if (packet.type() == ripple::liTX_NODE)
ret = ledger->takeTxNode(nodeIDs, nodeData);
else
ret = ledger->takeAsNode(nodeIDs, nodeData);

6
src/LedgerAcquire.h
View File

@@ -30,8 +30,8 @@ protected:
PeerSet(const uint256& hash, int interval);
virtual ~PeerSet() { ; }
void sendRequest(const newcoin::TMGetLedger& message);
void sendRequest(const newcoin::TMGetLedger& message, Peer::ref peer);
void sendRequest(const ripple::TMGetLedger& message);
void sendRequest(const ripple::TMGetLedger& message, Peer::ref peer);
public:
const uint256& getHash() const { return mHash; }
@@ -110,7 +110,7 @@ public:
LedgerAcquire::pointer find(const uint256& hash);
bool hasLedger(const uint256& ledgerHash);
void dropLedger(const uint256& ledgerHash);
bool gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref);
bool gotLedgerData(ripple::TMLedgerData& packet, Peer::ref);
};
#endif

44
src/LedgerConsensus.cpp
View File

@@ -59,9 +59,9 @@ void TransactionAcquire::trigger(Peer::ref peer, bool timer)
if (!mHaveRoot)
{
cLog(lsINFO) << "have no root";
newcoin::TMGetLedger tmGL;
ripple::TMGetLedger tmGL;
tmGL.set_ledgerhash(mHash.begin(), mHash.size());
tmGL.set_itype(newcoin::liTS_CANDIDATE);
tmGL.set_itype(ripple::liTS_CANDIDATE);
*(tmGL.add_nodeids()) = SHAMapNode().getRawString();
sendRequest(tmGL, peer);
}
@@ -82,9 +82,9 @@ void TransactionAcquire::trigger(Peer::ref peer, bool timer)
}
else
{
newcoin::TMGetLedger tmGL;
ripple::TMGetLedger tmGL;
tmGL.set_ledgerhash(mHash.begin(), mHash.size());
tmGL.set_itype(newcoin::liTS_CANDIDATE);
tmGL.set_itype(ripple::liTS_CANDIDATE);
for (std::vector<SHAMapNode>::iterator it = nodeIDs.begin(); it != nodeIDs.end(); ++it)
*(tmGL.add_nodeids()) = it->getRawString();
sendRequest(tmGL, peer);
@@ -464,10 +464,10 @@ void LedgerConsensus::mapComplete(const uint256& hash, SHAMap::ref map, bool acq
void LedgerConsensus::sendHaveTxSet(const uint256& hash, bool direct)
{
newcoin::TMHaveTransactionSet msg;
ripple::TMHaveTransactionSet msg;
msg.set_hash(hash.begin(), 256 / 8);
msg.set_status(direct ? newcoin::tsHAVE : newcoin::tsCAN_GET);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(msg, newcoin::mtHAVE_SET);
msg.set_status(direct ? ripple::tsHAVE : ripple::tsCAN_GET);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(msg, ripple::mtHAVE_SET);
theApp->getConnectionPool().relayMessage(NULL, packet);
}
@@ -481,11 +481,11 @@ void LedgerConsensus::adjustCount(SHAMap::ref map, const std::vector<uint160>& p
}
}
void LedgerConsensus::statusChange(newcoin::NodeEvent event, Ledger& ledger)
void LedgerConsensus::statusChange(ripple::NodeEvent event, Ledger& ledger)
{ // Send a node status change message to our peers
newcoin::TMStatusChange s;
ripple::TMStatusChange s;
if (!mHaveCorrectLCL)
s.set_newevent(newcoin::neLOST_SYNC);
s.set_newevent(ripple::neLOST_SYNC);
else
s.set_newevent(event);
s.set_ledgerseq(ledger.getLedgerSeq());
@@ -494,7 +494,7 @@ void LedgerConsensus::statusChange(newcoin::NodeEvent event, Ledger& ledger)
s.set_ledgerhashprevious(hash.begin(), hash.size());
hash = ledger.getHash();
s.set_ledgerhash(hash.begin(), hash.size());
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, newcoin::mtSTATUS_CHANGE);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, ripple::mtSTATUS_CHANGE);
theApp->getConnectionPool().relayMessage(NULL, packet);
cLog(lsINFO) << "send status change to peer";
}
@@ -539,7 +539,7 @@ void LedgerConsensus::closeLedger()
mConsensusStartTime = boost::posix_time::microsec_clock::universal_time();
mCloseTime = theApp->getOPs().getCloseTimeNC();
theApp->getOPs().setLastCloseTime(mCloseTime);
statusChange(newcoin::neCLOSING_LEDGER, *mPreviousLedger);
statusChange(ripple::neCLOSING_LEDGER, *mPreviousLedger);
takeInitialPosition(*theApp->getMasterLedger().closeLedger());
}
@@ -807,7 +807,7 @@ void LedgerConsensus::startAcquiring(const TransactionAcquire::pointer& acquire)
void LedgerConsensus::propose()
{
cLog(lsTRACE) << "We propose: " << mOurPosition->getCurrentHash();
newcoin::TMProposeSet prop;
ripple::TMProposeSet prop;
prop.set_currenttxhash(mOurPosition->getCurrentHash().begin(), 256 / 8);
prop.set_proposeseq(mOurPosition->getProposeSeq());
prop.set_closetime(mOurPosition->getCloseTime());
@@ -817,7 +817,7 @@ void LedgerConsensus::propose()
prop.set_nodepubkey(&pubKey[0], pubKey.size());
prop.set_signature(&sig[0], sig.size());
theApp->getConnectionPool().relayMessage(NULL,
boost::make_shared<PackedMessage>(prop, newcoin::mtPROPOSE_LEDGER));
boost::make_shared<PackedMessage>(prop, ripple::mtPROPOSE_LEDGER));
}
void LedgerConsensus::addDisputedTransaction(const uint256& txID, const std::vector<unsigned char>& tx)
@@ -850,11 +850,11 @@ void LedgerConsensus::addDisputedTransaction(const uint256& txID, const std::vec
if (!ourVote && theApp->isNew(txID))
{
newcoin::TMTransaction msg;
ripple::TMTransaction msg;
msg.set_rawtransaction(&(tx.front()), tx.size());
msg.set_status(newcoin::tsNEW);
msg.set_status(ripple::tsNEW);
msg.set_receivetimestamp(theApp->getOPs().getNetworkTimeNC());
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(msg, newcoin::mtTRANSACTION);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(msg, ripple::mtTRANSACTION);
theApp->getConnectionPool().relayMessage(NULL, packet);
}
}
@@ -907,9 +907,9 @@ bool LedgerConsensus::peerPosition(const LedgerProposal::pointer& newPosition)
return true;
}
bool LedgerConsensus::peerHasSet(Peer::ref peer, const uint256& hashSet, newcoin::TxSetStatus status)
bool LedgerConsensus::peerHasSet(Peer::ref peer, const uint256& hashSet, ripple::TxSetStatus status)
{
if (status != newcoin::tsHAVE) // Indirect requests are for future support
if (status != ripple::tsHAVE) // Indirect requests are for future support
return true;
std::vector< boost::weak_ptr<Peer> >& set = mPeerData[hashSet];
@@ -1114,7 +1114,7 @@ void LedgerConsensus::accept(SHAMap::ref set)
newLCL->setAccepted(closeTime, mCloseResolution, closeTimeCorrect);
newLCL->updateHash();
uint256 newLCLHash = newLCL->getHash();
statusChange(newcoin::neACCEPTED_LEDGER, *newLCL);
statusChange(ripple::neACCEPTED_LEDGER, *newLCL);
if (mValidating)
{
SerializedValidation::pointer v = boost::make_shared<SerializedValidation>
@@ -1122,10 +1122,10 @@ void LedgerConsensus::accept(SHAMap::ref set)
v->setTrusted();
theApp->getValidations().addValidation(v);
std::vector<unsigned char> validation = v->getSigned();
newcoin::TMValidation val;
ripple::TMValidation val;
val.set_validation(&validation[0], validation.size());
int j = theApp->getConnectionPool().relayMessage(NULL,
boost::make_shared<PackedMessage>(val, newcoin::mtVALIDATION));
boost::make_shared<PackedMessage>(val, ripple::mtVALIDATION));
cLog(lsINFO) << "CNF Val " << newLCLHash << " to " << j << " peers";
}
else

4
src/LedgerConsensus.h
View File

@@ -143,7 +143,7 @@ protected:
uint32 roundCloseTime(uint32 closeTime);
// manipulating our own position
void statusChange(newcoin::NodeEvent, Ledger& ledger);
void statusChange(ripple::NodeEvent, Ledger& ledger);
void takeInitialPosition(Ledger& initialLedger);
void updateOurPositions();
void playbackProposals();
@@ -182,7 +182,7 @@ public:
bool peerPosition(const LedgerProposal::pointer&);
void deferProposal(const LedgerProposal::pointer& proposal, const NewcoinAddress& peerPublic);
bool peerHasSet(Peer::ref peer, const uint256& set, newcoin::TxSetStatus status);
bool peerHasSet(Peer::ref peer, const uint256& set, ripple::TxSetStatus status);
bool peerGaveNodes(Peer::ref peer, const uint256& setHash,
const std::list<SHAMapNode>& nodeIDs, const std::list< std::vector<unsigned char> >& nodeData);

20
src/NetworkOPs.cpp
View File

@@ -154,14 +154,14 @@ Transaction::pointer NetworkOPs::processTransaction(Transaction::pointer trans,
// no cache the account balance information and always get it from the current ledger
// theApp->getWallet().applyTransaction(trans);
newcoin::TMTransaction tx;
ripple::TMTransaction tx;
Serializer s;
trans->getSTransaction()->add(s);
tx.set_rawtransaction(&s.getData().front(), s.getLength());
tx.set_status(newcoin::tsCURRENT);
tx.set_status(ripple::tsCURRENT);
tx.set_receivetimestamp(getNetworkTimeNC());
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tx, newcoin::mtTRANSACTION);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tx, ripple::mtTRANSACTION);
int sentTo = theApp->getConnectionPool().relayMessage(source, packet);
cLog(lsINFO) << "Transaction relayed to " << sentTo << " node(s)";
@@ -171,13 +171,13 @@ Transaction::pointer NetworkOPs::processTransaction(Transaction::pointer trans,
cLog(lsDEBUG) << "Status other than success " << r;
if ((mMode != omFULL) && (mMode != omTRACKING) && (theApp->isNew(trans->getID())))
{
newcoin::TMTransaction tx;
ripple::TMTransaction tx;
Serializer s;
trans->getSTransaction()->add(s);
tx.set_rawtransaction(&s.getData().front(), s.getLength());
tx.set_status(newcoin::tsCURRENT);
tx.set_status(ripple::tsCURRENT);
tx.set_receivetimestamp(getNetworkTimeNC());
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tx, newcoin::mtTRANSACTION);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tx, ripple::mtTRANSACTION);
theApp->getConnectionPool().relayMessage(source, packet);
}
@@ -624,15 +624,15 @@ void NetworkOPs::switchLastClosedLedger(Ledger::pointer newLedger, bool duringCo
Ledger::pointer openLedger = boost::make_shared<Ledger>(false, boost::ref(*newLedger));
mLedgerMaster->switchLedgers(newLedger, openLedger);
newcoin::TMStatusChange s;
s.set_newevent(newcoin::neSWITCHED_LEDGER);
ripple::TMStatusChange s;
s.set_newevent(ripple::neSWITCHED_LEDGER);
s.set_ledgerseq(newLedger->getLedgerSeq());
s.set_networktime(theApp->getOPs().getNetworkTimeNC());
uint256 hash = newLedger->getParentHash();
s.set_ledgerhashprevious(hash.begin(), hash.size());
hash = newLedger->getHash();
s.set_ledgerhash(hash.begin(), hash.size());
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, newcoin::mtSTATUS_CHANGE);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, ripple::mtSTATUS_CHANGE);
theApp->getConnectionPool().relayMessage(NULL, packet);
}
@@ -757,7 +757,7 @@ bool NetworkOPs::gotTXData(const boost::shared_ptr<Peer>& peer, const uint256& h
return mConsensus->peerGaveNodes(peer, hash, nodeIDs, nodeData);
}
bool NetworkOPs::hasTXSet(const boost::shared_ptr<Peer>& peer, const uint256& set, newcoin::TxSetStatus status)
bool NetworkOPs::hasTXSet(const boost::shared_ptr<Peer>& peer, const uint256& set, ripple::TxSetStatus status)
{
if (!haveConsensusObject())
{

2
src/NetworkOPs.h
View File

@@ -173,7 +173,7 @@ public:
const std::list<SHAMapNode>& nodeIDs, const std::list< std::vector<unsigned char> >& nodeData);
bool recvValidation(const SerializedValidation::pointer& val);
SHAMap::pointer getTXMap(const uint256& hash);
bool hasTXSet(const boost::shared_ptr<Peer>& peer, const uint256& set, newcoin::TxSetStatus status);
bool hasTXSet(const boost::shared_ptr<Peer>& peer, const uint256& set, ripple::TxSetStatus status);
void mapComplete(const uint256& hash, SHAMap::ref map);
// network state machine

184
src/Peer.cpp
View File

@@ -370,7 +370,7 @@ void Peer::processReadBuffer()
// std::cerr << "Peer::processReadBuffer: " << mIpPort.first << " " << mIpPort.second << std::endl;
// If connected and get a mtHELLO or if not connected and get a non-mtHELLO, wrong message was sent.
if (mHelloed == (type == newcoin::mtHELLO))
if (mHelloed == (type == ripple::mtHELLO))
{
cLog(lsWARNING) << "Wrong message type: " << type;
detach("prb1");
@@ -379,160 +379,160 @@ void Peer::processReadBuffer()
{
switch(type)
{
case newcoin::mtHELLO:
case ripple::mtHELLO:
{
newcoin::TMHello msg;
ripple::TMHello msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvHello(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtERROR_MSG:
case ripple::mtERROR_MSG:
{
newcoin::TMErrorMsg msg;
ripple::TMErrorMsg msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvErrorMessage(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtPING:
case ripple::mtPING:
{
newcoin::TMPing msg;
ripple::TMPing msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvPing(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtGET_CONTACTS:
case ripple::mtGET_CONTACTS:
{
newcoin::TMGetContacts msg;
ripple::TMGetContacts msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvGetContacts(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtCONTACT:
case ripple::mtCONTACT:
{
newcoin::TMContact msg;
ripple::TMContact msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvContact(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtGET_PEERS:
case ripple::mtGET_PEERS:
{
newcoin::TMGetPeers msg;
ripple::TMGetPeers msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvGetPeers(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtPEERS:
case ripple::mtPEERS:
{
newcoin::TMPeers msg;
ripple::TMPeers msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvPeers(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtSEARCH_TRANSACTION:
case ripple::mtSEARCH_TRANSACTION:
{
newcoin::TMSearchTransaction msg;
ripple::TMSearchTransaction msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvSearchTransaction(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtGET_ACCOUNT:
case ripple::mtGET_ACCOUNT:
{
newcoin::TMGetAccount msg;
ripple::TMGetAccount msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvGetAccount(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtACCOUNT:
case ripple::mtACCOUNT:
{
newcoin::TMAccount msg;
ripple::TMAccount msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvAccount(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtTRANSACTION:
case ripple::mtTRANSACTION:
{
newcoin::TMTransaction msg;
ripple::TMTransaction msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvTransaction(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtSTATUS_CHANGE:
case ripple::mtSTATUS_CHANGE:
{
newcoin::TMStatusChange msg;
ripple::TMStatusChange msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvStatus(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtPROPOSE_LEDGER:
case ripple::mtPROPOSE_LEDGER:
{
newcoin::TMProposeSet msg;
ripple::TMProposeSet msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvPropose(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtGET_LEDGER:
case ripple::mtGET_LEDGER:
{
newcoin::TMGetLedger msg;
ripple::TMGetLedger msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvGetLedger(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtLEDGER_DATA:
case ripple::mtLEDGER_DATA:
{
newcoin::TMLedgerData msg;
ripple::TMLedgerData msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvLedger(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtHAVE_SET:
case ripple::mtHAVE_SET:
{
newcoin::TMHaveTransactionSet msg;
ripple::TMHaveTransactionSet msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvHaveTxSet(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
case newcoin::mtVALIDATION:
case ripple::mtVALIDATION:
{
newcoin::TMValidation msg;
ripple::TMValidation msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvValidation(msg);
else std::cerr << "parse error: " << type << std::endl;
}
break;
#if 0
case newcoin::mtGET_VALIDATION:
case ripple::mtGET_VALIDATION:
{
newcoin::TM msg;
ripple::TM msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recv(msg);
else std::cerr << "parse error: " << type << std::endl;
@@ -540,9 +540,9 @@ void Peer::processReadBuffer()
break;
#endif
case newcoin::mtGET_OBJECTS:
case ripple::mtGET_OBJECTS:
{
newcoin::TMGetObjectByHash msg;
ripple::TMGetObjectByHash msg;
if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
recvGetObjectByHash(msg);
else std::cerr << "parse error: " << type << std::endl;
@@ -556,7 +556,7 @@ void Peer::processReadBuffer()
}
}
void Peer::recvHello(newcoin::TMHello& packet)
void Peer::recvHello(ripple::TMHello& packet)
{
bool bDetach = true;
@@ -667,7 +667,7 @@ void Peer::recvHello(newcoin::TMHello& packet)
}
}
void Peer::recvTransaction(newcoin::TMTransaction& packet)
void Peer::recvTransaction(ripple::TMTransaction& packet)
{
#ifdef DEBUG
std::cerr << "Got transaction from peer" << std::endl;
@@ -708,7 +708,7 @@ void Peer::recvTransaction(newcoin::TMTransaction& packet)
}
}
void Peer::recvPropose(newcoin::TMProposeSet& packet)
void Peer::recvPropose(ripple::TMProposeSet& packet)
{
if ((packet.currenttxhash().size() != 32) || (packet.nodepubkey().size() < 28) ||
(packet.signature().size() < 56))
@@ -726,12 +726,12 @@ void Peer::recvPropose(newcoin::TMProposeSet& packet)
if(theApp->getOPs().recvPropose(packet.proposeseq(), currentTxHash, prevLedger, packet.closetime(),
packet.nodepubkey(), packet.signature(), mNodePublic))
{ // FIXME: Not all nodes will want proposals
PackedMessage::pointer message = boost::make_shared<PackedMessage>(packet, newcoin::mtPROPOSE_LEDGER);
PackedMessage::pointer message = boost::make_shared<PackedMessage>(packet, ripple::mtPROPOSE_LEDGER);
theApp->getConnectionPool().relayMessage(this, message);
}
}
void Peer::recvHaveTxSet(newcoin::TMHaveTransactionSet& packet)
void Peer::recvHaveTxSet(ripple::TMHaveTransactionSet& packet)
{
// FIXME: We should have some limit on the number of HaveTxSet messages a peer can send us
// per consensus pass, to keep a peer from running up our memory without limit
@@ -743,13 +743,13 @@ void Peer::recvHaveTxSet(newcoin::TMHaveTransactionSet& packet)
}
uint256 hash;
memcpy(hash.begin(), packet.hash().data(), 32);
if (packet.status() == newcoin::tsHAVE)
if (packet.status() == ripple::tsHAVE)
addTxSet(hash);
if (!theApp->getOPs().hasTXSet(shared_from_this(), hash, packet.status()))
punishPeer(PP_UNWANTED_DATA);
}
void Peer::recvValidation(newcoin::TMValidation& packet)
void Peer::recvValidation(ripple::TMValidation& packet)
{
if (packet.validation().size() < 50)
{
@@ -784,7 +784,7 @@ void Peer::recvValidation(newcoin::TMValidation& packet)
if (theApp->getOPs().recvValidation(val))
{
PackedMessage::pointer message = boost::make_shared<PackedMessage>(packet, newcoin::mtVALIDATION);
PackedMessage::pointer message = boost::make_shared<PackedMessage>(packet, ripple::mtVALIDATION);
theApp->getConnectionPool().relayMessage(this, message);
}
}
@@ -797,22 +797,22 @@ void Peer::recvValidation(newcoin::TMValidation& packet)
//#endif
}
void Peer::recvGetValidation(newcoin::TMGetValidations& packet)
void Peer::recvGetValidation(ripple::TMGetValidations& packet)
{
}
void Peer::recvContact(newcoin::TMContact& packet)
void Peer::recvContact(ripple::TMContact& packet)
{
}
void Peer::recvGetContacts(newcoin::TMGetContacts& packet)
void Peer::recvGetContacts(ripple::TMGetContacts& packet)
{
}
// return a list of your favorite people
// TODO: filter out all the LAN peers
// TODO: filter out the peer you are talking to
void Peer::recvGetPeers(newcoin::TMGetPeers& packet)
void Peer::recvGetPeers(ripple::TMGetPeers& packet)
{
std::vector<std::string> addrs;
@@ -820,7 +820,7 @@ void Peer::recvGetPeers(newcoin::TMGetPeers& packet)
if (!addrs.empty())
{
newcoin::TMPeers peers;
ripple::TMPeers peers;
for (unsigned int n=0; n<addrs.size(); n++)
{
@@ -830,20 +830,20 @@ void Peer::recvGetPeers(newcoin::TMGetPeers& packet)
splitIpPort(addrs[n], strIP, iPort);
// XXX This should also ipv6
newcoin::TMIPv4EndPoint* addr=peers.add_nodes();
ripple::TMIPv4EndPoint* addr=peers.add_nodes();
addr->set_ipv4(inet_addr(strIP.c_str()));
addr->set_ipv4port(iPort);
//cLog(lsINFO) << "Peer: Teaching: " << ADDRESS(this) << ": " << n << ": " << strIP << " " << iPort;
}
PackedMessage::pointer message = boost::make_shared<PackedMessage>(peers, newcoin::mtPEERS);
PackedMessage::pointer message = boost::make_shared<PackedMessage>(peers, ripple::mtPEERS);
sendPacket(message);
}
}
// TODO: filter out all the LAN peers
void Peer::recvPeers(newcoin::TMPeers& packet)
void Peer::recvPeers(ripple::TMPeers& packet)
{
for (int i = 0; i < packet.nodes().size(); ++i)
{
@@ -863,11 +863,11 @@ void Peer::recvPeers(newcoin::TMPeers& packet)
}
}
void Peer::recvGetObjectByHash(newcoin::TMGetObjectByHash& packet)
void Peer::recvGetObjectByHash(ripple::TMGetObjectByHash& packet)
{
if (packet.query())
{ // this is a query
newcoin::TMGetObjectByHash reply;
ripple::TMGetObjectByHash reply;
reply.clear_query();
if (packet.has_seq())
@@ -880,14 +880,14 @@ void Peer::recvGetObjectByHash(newcoin::TMGetObjectByHash& packet)
for (unsigned i = 0; i < packet.objects_size(); ++i)
{
uint256 hash;
const newcoin::TMIndexedObject& obj = packet.objects(i);
const ripple::TMIndexedObject& obj = packet.objects(i);
if (obj.has_hash() && (obj.hash().size() == (256/8)))
{
memcpy(hash.begin(), obj.hash().data(), 256 / 8);
HashedObject::pointer hObj = theApp->getHashedObjectStore().retrieve(hash);
if (hObj)
{
newcoin::TMIndexedObject& newObj = *reply.add_objects();
ripple::TMIndexedObject& newObj = *reply.add_objects();
newObj.set_hash(hash.begin(), hash.size());
newObj.set_data(&hObj->getData().front(), hObj->getData().size());
if (obj.has_nodeid())
@@ -896,7 +896,7 @@ void Peer::recvGetObjectByHash(newcoin::TMGetObjectByHash& packet)
}
}
cLog(lsDEBUG) << "GetObjByHash query: had " << reply.objects_size() << " of " << packet.objects_size();
sendPacket(boost::make_shared<PackedMessage>(packet, newcoin::mtGET_OBJECTS));
sendPacket(boost::make_shared<PackedMessage>(packet, ripple::mtGET_OBJECTS));
}
else
{ // this is a reply
@@ -904,27 +904,27 @@ void Peer::recvGetObjectByHash(newcoin::TMGetObjectByHash& packet)
}
}
void Peer::recvPing(newcoin::TMPing& packet)
void Peer::recvPing(ripple::TMPing& packet)
{
}
void Peer::recvErrorMessage(newcoin::TMErrorMsg& packet)
void Peer::recvErrorMessage(ripple::TMErrorMsg& packet)
{
}
void Peer::recvSearchTransaction(newcoin::TMSearchTransaction& packet)
void Peer::recvSearchTransaction(ripple::TMSearchTransaction& packet)
{
}
void Peer::recvGetAccount(newcoin::TMGetAccount& packet)
void Peer::recvGetAccount(ripple::TMGetAccount& packet)
{
}
void Peer::recvAccount(newcoin::TMAccount& packet)
void Peer::recvAccount(ripple::TMAccount& packet)
{
}
void Peer::recvStatus(newcoin::TMStatusChange& packet)
void Peer::recvStatus(ripple::TMStatusChange& packet)
{
cLog(lsTRACE) << "Received status change from peer " << getIP();
if (!packet.has_networktime())
@@ -934,12 +934,12 @@ void Peer::recvStatus(newcoin::TMStatusChange& packet)
mLastStatus = packet;
else
{ // preserve old status
newcoin::NodeStatus status = mLastStatus.newstatus();
ripple::NodeStatus status = mLastStatus.newstatus();
mLastStatus = packet;
packet.set_newstatus(status);
}
if (packet.newevent() == newcoin::neLOST_SYNC)
if (packet.newevent() == ripple::neLOST_SYNC)
{
if (!mClosedLedgerHash.isZero())
{
@@ -969,13 +969,13 @@ void Peer::recvStatus(newcoin::TMStatusChange& packet)
else mPreviousLedgerHash.zero();
}
void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
void Peer::recvGetLedger(ripple::TMGetLedger& packet)
{
SHAMap::pointer map;
newcoin::TMLedgerData reply;
ripple::TMLedgerData reply;
bool fatLeaves = true, fatRoot = false;
if (packet.itype() == newcoin::liTS_CANDIDATE)
if (packet.itype() == ripple::liTS_CANDIDATE)
{ // Request is for a transaction candidate set
cLog(lsINFO) << "Received request for TX candidate set data " << getIP();
if ((!packet.has_ledgerhash() || packet.ledgerhash().size() != 32))
@@ -994,7 +994,7 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
}
reply.set_ledgerseq(0);
reply.set_ledgerhash(txHash.begin(), txHash.size());
reply.set_type(newcoin::liTS_CANDIDATE);
reply.set_type(ripple::liTS_CANDIDATE);
fatLeaves = false; // We'll already have most transactions
fatRoot = true; // Save a pass
}
@@ -1017,9 +1017,9 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
}
else if (packet.has_ledgerseq())
ledger = theApp->getMasterLedger().getLedgerBySeq(packet.ledgerseq());
else if (packet.has_ltype() && (packet.ltype() == newcoin::ltCURRENT))
else if (packet.has_ltype() && (packet.ltype() == ripple::ltCURRENT))
ledger = theApp->getMasterLedger().getCurrentLedger();
else if (packet.has_ltype() && (packet.ltype() == newcoin::ltCLOSED) )
else if (packet.has_ltype() && (packet.ltype() == ripple::ltCLOSED) )
{
ledger = theApp->getMasterLedger().getClosedLedger();
if (ledger && !ledger->isClosed())
@@ -1045,7 +1045,7 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
reply.set_ledgerseq(ledger->getLedgerSeq());
reply.set_type(packet.itype());
if(packet.itype() == newcoin::liBASE)
if(packet.itype() == ripple::liBASE)
{ // they want the ledger base data
cLog(lsTRACE) << "Want ledger base data";
Serializer nData(128);
@@ -1076,13 +1076,13 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
}
}
PackedMessage::pointer oPacket = boost::make_shared<PackedMessage>(reply, newcoin::mtLEDGER_DATA);
PackedMessage::pointer oPacket = boost::make_shared<PackedMessage>(reply, ripple::mtLEDGER_DATA);
sendPacket(oPacket);
return;
}
if ((packet.itype() == newcoin::liTX_NODE) || (packet.itype() == newcoin::liAS_NODE))
map = (packet.itype() == newcoin::liTX_NODE) ?
if ((packet.itype() == ripple::liTX_NODE) || (packet.itype() == ripple::liAS_NODE))
map = (packet.itype() == ripple::liTX_NODE) ?
ledger->peekTransactionMap() : ledger->peekAccountStateMap();
}
@@ -1113,7 +1113,7 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
{
Serializer nID(33);
nodeIDIterator->addIDRaw(nID);
newcoin::TMLedgerNode* node = reply.add_nodes();
ripple::TMLedgerNode* node = reply.add_nodes();
node->set_nodeid(nID.getDataPtr(), nID.getLength());
node->set_nodedata(&rawNodeIterator->front(), rawNodeIterator->size());
++count;
@@ -1122,11 +1122,11 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
}
if (packet.has_requestcookie())
reply.set_requestcookie(packet.requestcookie());
PackedMessage::pointer oPacket = boost::make_shared<PackedMessage>(reply, newcoin::mtLEDGER_DATA);
PackedMessage::pointer oPacket = boost::make_shared<PackedMessage>(reply, ripple::mtLEDGER_DATA);
sendPacket(oPacket);
}
void Peer::recvLedger(newcoin::TMLedgerData& packet)
void Peer::recvLedger(ripple::TMLedgerData& packet)
{
if (packet.nodes().size() <= 0)
{
@@ -1134,7 +1134,7 @@ void Peer::recvLedger(newcoin::TMLedgerData& packet)
return;
}
if (packet.type() == newcoin::liTS_CANDIDATE)
if (packet.type() == ripple::liTS_CANDIDATE)
{ // got data for a candidate transaction set
uint256 hash;
if(packet.ledgerhash().size() != 32)
@@ -1150,7 +1150,7 @@ void Peer::recvLedger(newcoin::TMLedgerData& packet)
for (int i = 0; i < packet.nodes().size(); ++i)
{
const newcoin::TMLedgerNode& node = packet.nodes(i);
const ripple::TMLedgerNode& node = packet.nodes(i);
if (!node.has_nodeid() || !node.has_nodedata() || (node.nodeid().size() != 33))
{
cLog(lsWARNING) << "LedgerData request with invalid node ID";
@@ -1244,7 +1244,7 @@ void Peer::sendHello()
theApp->getWallet().getNodePrivate().signNodePrivate(mCookieHash, vchSig);
newcoin::TMHello h;
ripple::TMHello h;
h.set_protoversion(MAKE_VERSION_INT(PROTO_VERSION_MAJOR, PROTO_VERSION_MINOR));
h.set_protoversionmin(MAKE_VERSION_INT(MIN_PROTO_MAJOR, MIN_PROTO_MINOR));
@@ -1263,18 +1263,18 @@ void Peer::sendHello()
h.set_ledgerprevious(hash.begin(), hash.GetSerializeSize());
}
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(h, newcoin::mtHELLO);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(h, ripple::mtHELLO);
sendPacket(packet);
}
void Peer::sendGetPeers()
{
// get other peers this guy knows about
newcoin::TMGetPeers getPeers;
ripple::TMGetPeers getPeers;
getPeers.set_doweneedthis(1);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(getPeers, newcoin::mtGET_PEERS);
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(getPeers, ripple::mtGET_PEERS);
sendPacket(packet);
}
@@ -1308,11 +1308,11 @@ Json::Value Peer::getJson()
{
switch (mLastStatus.newstatus())
{
case newcoin::nsCONNECTING: ret["status"] = "connecting"; break;
case newcoin::nsCONNECTED: ret["status"] = "connected"; break;
case newcoin::nsMONITORING: ret["status"] = "monitoring"; break;
case newcoin::nsVALIDATING: ret["status"] = "validating"; break;
case newcoin::nsSHUTTING: ret["status"] = "shutting"; break;
case ripple::nsCONNECTING: ret["status"] = "connecting"; break;
case ripple::nsCONNECTED: ret["status"] = "connected"; break;
case ripple::nsMONITORING: ret["status"] = "monitoring"; break;
case ripple::nsVALIDATING: ret["status"] = "validating"; break;
case ripple::nsSHUTTING: ret["status"] = "shutting"; break;
default: cLog(lsWARNING) << "Peer has unknown status: " << mLastStatus.newstatus();
}
}

42
src/Peer.h
View File

@@ -65,8 +65,8 @@ protected:
std::vector<uint8_t> mReadbuf;
std::list<PackedMessage::pointer> mSendQ;
PackedMessage::pointer mSendingPacket;
newcoin::TMStatusChange mLastStatus;
newcoin::TMHello mHello;
ripple::TMStatusChange mLastStatus;
ripple::TMHello mHello;
Peer(boost::asio::io_service& io_service, boost::asio::ssl::context& ctx);
@@ -94,25 +94,25 @@ protected:
void sendHello();
void recvHello(newcoin::TMHello& packet);
void recvTransaction(newcoin::TMTransaction& packet);
void recvValidation(newcoin::TMValidation& packet);
void recvGetValidation(newcoin::TMGetValidations& packet);
void recvContact(newcoin::TMContact& packet);
void recvGetContacts(newcoin::TMGetContacts& packet);
void recvGetPeers(newcoin::TMGetPeers& packet);
void recvPeers(newcoin::TMPeers& packet);
void recvGetObjectByHash(newcoin::TMGetObjectByHash& packet);
void recvPing(newcoin::TMPing& packet);
void recvErrorMessage(newcoin::TMErrorMsg& packet);
void recvSearchTransaction(newcoin::TMSearchTransaction& packet);
void recvGetAccount(newcoin::TMGetAccount& packet);
void recvAccount(newcoin::TMAccount& packet);
void recvGetLedger(newcoin::TMGetLedger& packet);
void recvLedger(newcoin::TMLedgerData& packet);
void recvStatus(newcoin::TMStatusChange& packet);
void recvPropose(newcoin::TMProposeSet& packet);
void recvHaveTxSet(newcoin::TMHaveTransactionSet& packet);
void recvHello(ripple::TMHello& packet);
void recvTransaction(ripple::TMTransaction& packet);
void recvValidation(ripple::TMValidation& packet);
void recvGetValidation(ripple::TMGetValidations& packet);
void recvContact(ripple::TMContact& packet);
void recvGetContacts(ripple::TMGetContacts& packet);
void recvGetPeers(ripple::TMGetPeers& packet);
void recvPeers(ripple::TMPeers& packet);
void recvGetObjectByHash(ripple::TMGetObjectByHash& packet);
void recvPing(ripple::TMPing& packet);
void recvErrorMessage(ripple::TMErrorMsg& packet);
void recvSearchTransaction(ripple::TMSearchTransaction& packet);
void recvGetAccount(ripple::TMGetAccount& packet);
void recvAccount(ripple::TMAccount& packet);
void recvGetLedger(ripple::TMGetLedger& packet);
void recvLedger(ripple::TMLedgerData& packet);
void recvStatus(ripple::TMStatusChange& packet);
void recvPropose(ripple::TMProposeSet& packet);
void recvHaveTxSet(ripple::TMHaveTransactionSet& packet);
void getSessionCookie(std::string& strDst);

2
src/ripple.proto
View File

@@ -1,4 +1,4 @@
package newcoin;
package ripple;
enum MessageType {
// core