ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-21 11:35:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename ripple namespace used for protobuf to 'protocol'

Browse Source
This commit is contained in:
Vinnie Falco
2013-06-17 09:52:41 -07:00
parent e96bd1182e
commit 7474c17823
13 changed files with 227 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/cpp/ripple/LedgerMaster.cpp
View File

@@ -350,8 +350,8 @@ bool LedgerMaster::acquireMissingLedger (Ledger::ref origLedger, uint256 const&
if (nextLedger)
{
ripple::TMGetObjectByHash tmBH;
tmBH.set_type (ripple::TMGetObjectByHash::otFETCH_PACK);
protocol::TMGetObjectByHash tmBH;
tmBH.set_type (protocol::TMGetObjectByHash::otFETCH_PACK);
tmBH.set_query (true);
tmBH.set_seq (ledgerSeq);
tmBH.set_ledgerhash (ledgerHash.begin (), 32);
@@ -373,7 +373,7 @@ bool LedgerMaster::acquireMissingLedger (Ledger::ref origLedger, uint256 const&
if (target)
{
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tmBH, ripple::mtGET_OBJECTS);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tmBH, protocol::mtGET_OBJECTS);
target->sendPacket (packet, false);
}
else

38
src/cpp/ripple/NetworkOPs.cpp
View File

@@ -295,14 +295,14 @@ void NetworkOPs::runTransactionQueue ()
if (theApp->getHashRouter ().swapSet (txn->getID (), peers, SF_RELAYED))
{
ripple::TMTransaction tx;
protocol::TMTransaction tx;
Serializer s;
dbtx->getSTransaction ()->add (s);
tx.set_rawtransaction (&s.getData ().front (), s.getLength ());
tx.set_status (ripple::tsCURRENT);
tx.set_status (protocol::tsCURRENT);
tx.set_receivetimestamp (getNetworkTimeNC ()); // FIXME: This should be when we received it
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tx, ripple::mtTRANSACTION);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tx, protocol::mtTRANSACTION);
theApp->getPeers ().relayMessageBut (peers, packet);
}
}
@@ -404,14 +404,14 @@ Transaction::pointer NetworkOPs::processTransaction (Transaction::pointer trans,
if (theApp->getHashRouter ().swapSet (trans->getID (), peers, SF_RELAYED))
{
ripple::TMTransaction tx;
protocol::TMTransaction tx;
Serializer s;
trans->getSTransaction ()->add (s);
tx.set_rawtransaction (&s.getData ().front (), s.getLength ());
tx.set_status (ripple::tsCURRENT);
tx.set_status (protocol::tsCURRENT);
tx.set_receivetimestamp (getNetworkTimeNC ()); // FIXME: This should be when we received it
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tx, ripple::mtTRANSACTION);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tx, protocol::mtTRANSACTION);
theApp->getPeers ().relayMessageBut (peers, packet);
}
}
@@ -856,15 +856,15 @@ void NetworkOPs::switchLastClosedLedger (Ledger::pointer newLedger, bool duringC
Ledger::pointer openLedger = boost::make_shared<Ledger> (false, boost::ref (*newLedger));
mLedgerMaster->switchLedgers (newLedger, openLedger);
ripple::TMStatusChange s;
s.set_newevent (ripple::neSWITCHED_LEDGER);
protocol::TMStatusChange s;
s.set_newevent (protocol::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, ripple::mtSTATUS_CHANGE);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (s, protocol::mtSTATUS_CHANGE);
theApp->getPeers ().relayMessage (NULL, packet);
}
@@ -935,7 +935,7 @@ uint256 NetworkOPs::getConsensusLCL ()
}
void NetworkOPs::processTrustedProposal (LedgerProposal::pointer proposal,
boost::shared_ptr<ripple::TMProposeSet> set, RippleAddress nodePublic, uint256 checkLedger, bool sigGood)
boost::shared_ptr<protocol::TMProposeSet> set, RippleAddress nodePublic, uint256 checkLedger, bool sigGood)
{
boost::recursive_mutex::scoped_lock sl (theApp->getMasterLock ());
@@ -975,7 +975,7 @@ void NetworkOPs::processTrustedProposal (LedgerProposal::pointer proposal,
{
std::set<uint64> peers;
theApp->getHashRouter ().swapSet (proposal->getHashRouter (), peers, SF_RELAYED);
PackedMessage::pointer message = boost::make_shared<PackedMessage> (*set, ripple::mtPROPOSE_LEDGER);
PackedMessage::pointer message = boost::make_shared<PackedMessage> (*set, protocol::mtPROPOSE_LEDGER);
theApp->getPeers ().relayMessageBut (peers, message);
}
else
@@ -1028,7 +1028,7 @@ SHAMapAddNode NetworkOPs::gotTXData (const boost::shared_ptr<Peer>& peer, uint25
return mConsensus->peerGaveNodes (peer, hash, nodeIDs, nodeData);
}
bool NetworkOPs::hasTXSet (const boost::shared_ptr<Peer>& peer, uint256 const& set, ripple::TxSetStatus status)
bool NetworkOPs::hasTXSet (const boost::shared_ptr<Peer>& peer, uint256 const& set, protocol::TxSetStatus status)
{
if (!haveConsensusObject ())
{
@@ -2130,17 +2130,17 @@ void NetworkOPs::getBookPage (Ledger::pointer lpLedger, const uint160& uTakerPay
// jvResult["nodes"] = Json::Value(Json::arrayValue);
}
static void fpAppender (ripple::TMGetObjectByHash* reply, uint32 ledgerSeq,
static void fpAppender (protocol::TMGetObjectByHash* reply, uint32 ledgerSeq,
const uint256& hash, const Blob& blob)
{
ripple::TMIndexedObject& newObj = * (reply->add_objects ());
protocol::TMIndexedObject& newObj = * (reply->add_objects ());
newObj.set_ledgerseq (ledgerSeq);
newObj.set_hash (hash.begin (), 256 / 8);
newObj.set_data (&blob[0], blob.size ());
}
void NetworkOPs::makeFetchPack (Job&, boost::weak_ptr<Peer> wPeer,
boost::shared_ptr<ripple::TMGetObjectByHash> request,
boost::shared_ptr<protocol::TMGetObjectByHash> request,
Ledger::pointer wantLedger, Ledger::pointer haveLedger, uint32 uUptime)
{
if (UptimeTimer::getInstance ().getElapsedSeconds () > (uUptime + 1))
@@ -2162,20 +2162,20 @@ void NetworkOPs::makeFetchPack (Job&, boost::weak_ptr<Peer> wPeer,
if (!peer)
return;
ripple::TMGetObjectByHash reply;
protocol::TMGetObjectByHash reply;
reply.set_query (false);
if (request->has_seq ())
reply.set_seq (request->seq ());
reply.set_ledgerhash (request->ledgerhash ());
reply.set_type (ripple::TMGetObjectByHash::otFETCH_PACK);
reply.set_type (protocol::TMGetObjectByHash::otFETCH_PACK);
do
{
uint32 lSeq = wantLedger->getLedgerSeq ();
ripple::TMIndexedObject& newObj = *reply.add_objects ();
protocol::TMIndexedObject& newObj = *reply.add_objects ();
newObj.set_hash (wantLedger->getHash ().begin (), 256 / 8);
Serializer s (256);
s.add32 (HashPrefix::ledgerMaster);
@@ -2199,7 +2199,7 @@ void NetworkOPs::makeFetchPack (Job&, boost::weak_ptr<Peer> wPeer,
while (wantLedger && (UptimeTimer::getInstance ().getElapsedSeconds () <= (uUptime + 1)));
WriteLog (lsINFO, NetworkOPs) << "Built fetch pack with " << reply.objects ().size () << " nodes";
PackedMessage::pointer msg = boost::make_shared<PackedMessage> (reply, ripple::mtGET_OBJECTS);
PackedMessage::pointer msg = boost::make_shared<PackedMessage> (reply, protocol::mtGET_OBJECTS);
peer->sendPacket (msg, false);
}
catch (...)

6
src/cpp/ripple/NetworkOPs.h
View File

@@ -206,17 +206,17 @@ public:
Blob const& myNode, std::list< Blob >& newNodes);
// ledger proposal/close functions
void processTrustedProposal (LedgerProposal::pointer proposal, boost::shared_ptr<ripple::TMProposeSet> set,
void processTrustedProposal (LedgerProposal::pointer proposal, boost::shared_ptr<protocol::TMProposeSet> set,
RippleAddress nodePublic, uint256 checkLedger, bool sigGood);
SHAMapAddNode gotTXData (const boost::shared_ptr<Peer>& peer, uint256 const& hash,
const std::list<SHAMapNode>& nodeIDs, const std::list< Blob >& nodeData);
bool recvValidation (SerializedValidation::ref val, const std::string& source);
void takePosition (int seq, SHAMap::ref position);
SHAMap::pointer getTXMap (uint256 const& hash);
bool hasTXSet (const boost::shared_ptr<Peer>& peer, uint256 const& set, ripple::TxSetStatus status);
bool hasTXSet (const boost::shared_ptr<Peer>& peer, uint256 const& set, protocol::TxSetStatus status);
void mapComplete (uint256 const& hash, SHAMap::ref map);
bool stillNeedTXSet (uint256 const& hash);
void makeFetchPack (Job&, boost::weak_ptr<Peer> peer, boost::shared_ptr<ripple::TMGetObjectByHash> request,
void makeFetchPack (Job&, boost::weak_ptr<Peer> peer, boost::shared_ptr<protocol::TMGetObjectByHash> request,
Ledger::pointer wantLedger, Ledger::pointer haveLedger, uint32 uUptime);
bool shouldFetchPack (uint32 seq);
void gotFetchPack (bool progress, uint32 seq);

2
src/cpp/ripple/ripple.proto
View File

@@ -1,6 +1,6 @@
// VFALCO TODO Rename the protobuf namespace from ripple to 'wire' or something
//
package ripple;
package protocol;
enum MessageType
{

34
src/cpp/ripple/ripple_InboundLedger.cpp
View File

@@ -317,12 +317,12 @@ void InboundLedger::trigger (Peer::ref peer)
}
}
ripple::TMGetLedger tmGL;
protocol::TMGetLedger tmGL;
tmGL.set_ledgerhash (mHash.begin (), mHash.size ());
if (getTimeouts () != 0)
{
tmGL.set_querytype (ripple::qtINDIRECT);
tmGL.set_querytype (protocol::qtINDIRECT);
if (!isProgress () && !mFailed && mByHash && (getTimeouts () > LEDGER_TIMEOUT_AGGRESSIVE))
{
@@ -330,7 +330,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (!need.empty ())
{
ripple::TMGetObjectByHash tmBH;
protocol::TMGetObjectByHash tmBH;
tmBH.set_query (true);
tmBH.set_ledgerhash (mHash.begin (), mHash.size ());
bool typeSet = false;
@@ -346,11 +346,11 @@ void InboundLedger::trigger (Peer::ref peer)
if (p.first == tmBH.type ())
{
ripple::TMIndexedObject* io = tmBH.add_objects ();
protocol::TMIndexedObject* io = tmBH.add_objects ();
io->set_hash (p.second.begin (), p.second.size ());
}
}
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tmBH, ripple::mtGET_OBJECTS);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tmBH, protocol::mtGET_OBJECTS);
{
boost::recursive_mutex::scoped_lock sl (mLock);
@@ -381,7 +381,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (!mHaveBase && !mFailed)
{
tmGL.set_itype (ripple::liBASE);
tmGL.set_itype (protocol::liBASE);
WriteLog (lsTRACE, InboundLedger) << "Sending base request to " << (peer ? "selected peer" : "all peers");
sendRequest (tmGL, peer);
return;
@@ -397,7 +397,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (mLedger->peekTransactionMap ()->getHash ().isZero ())
{
// we need the root node
tmGL.set_itype (ripple::liTX_NODE);
tmGL.set_itype (protocol::liTX_NODE);
* (tmGL.add_nodeids ()) = SHAMapNode ().getRawString ();
WriteLog (lsTRACE, InboundLedger) << "Sending TX root request to " << (peer ? "selected peer" : "all peers");
sendRequest (tmGL, peer);
@@ -430,7 +430,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (!nodeIDs.empty ())
{
tmGL.set_itype (ripple::liTX_NODE);
tmGL.set_itype (protocol::liTX_NODE);
BOOST_FOREACH (SHAMapNode & it, nodeIDs)
{
* (tmGL.add_nodeids ()) = it.getRawString ();
@@ -450,7 +450,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (mLedger->peekAccountStateMap ()->getHash ().isZero ())
{
// we need the root node
tmGL.set_itype (ripple::liAS_NODE);
tmGL.set_itype (protocol::liAS_NODE);
* (tmGL.add_nodeids ()) = SHAMapNode ().getRawString ();
WriteLog (lsTRACE, InboundLedger) << "Sending AS root request to " << (peer ? "selected peer" : "all peers");
sendRequest (tmGL, peer);
@@ -483,7 +483,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (!nodeIDs.empty ())
{
tmGL.set_itype (ripple::liAS_NODE);
tmGL.set_itype (protocol::liAS_NODE);
BOOST_FOREACH (SHAMapNode & it, nodeIDs)
* (tmGL.add_nodeids ()) = it.getRawString ();
WriteLog (lsTRACE, InboundLedger) << "Sending AS node " << nodeIDs.size ()
@@ -506,22 +506,22 @@ void InboundLedger::trigger (Peer::ref peer)
}
}
void PeerSet::sendRequest (const ripple::TMGetLedger& tmGL, Peer::ref peer)
void PeerSet::sendRequest (const protocol::TMGetLedger& tmGL, Peer::ref peer)
{
if (!peer)
sendRequest (tmGL);
else
peer->sendPacket (boost::make_shared<PackedMessage> (tmGL, ripple::mtGET_LEDGER), false);
peer->sendPacket (boost::make_shared<PackedMessage> (tmGL, protocol::mtGET_LEDGER), false);
}
void PeerSet::sendRequest (const ripple::TMGetLedger& tmGL)
void PeerSet::sendRequest (const protocol::TMGetLedger& tmGL)
{
boost::recursive_mutex::scoped_lock sl (mLock);
if (mPeers.empty ())
return;
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tmGL, ripple::mtGET_LEDGER);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (tmGL, protocol::mtGET_LEDGER);
for (boost::unordered_map<uint64, int>::iterator it = mPeers.begin (), end = mPeers.end (); it != end; ++it)
{
@@ -805,7 +805,7 @@ std::vector<InboundLedger::neededHash_t> InboundLedger::getNeededHashes ()
if (!mHaveBase)
{
ret.push_back (std::make_pair (ripple::TMGetObjectByHash::otLEDGER, mHash));
ret.push_back (std::make_pair (protocol::TMGetObjectByHash::otLEDGER, mHash));
return ret;
}
@@ -814,7 +814,7 @@ std::vector<InboundLedger::neededHash_t> InboundLedger::getNeededHashes ()
AccountStateSF filter (mLedger->getLedgerSeq ());
std::vector<uint256> v = mLedger->getNeededAccountStateHashes (4, &filter);
BOOST_FOREACH (uint256 const & h, v)
ret.push_back (std::make_pair (ripple::TMGetObjectByHash::otSTATE_NODE, h));
ret.push_back (std::make_pair (protocol::TMGetObjectByHash::otSTATE_NODE, h));
}
if (!mHaveTransactions)
@@ -822,7 +822,7 @@ std::vector<InboundLedger::neededHash_t> InboundLedger::getNeededHashes ()
TransactionStateSF filter (mLedger->getLedgerSeq ());
std::vector<uint256> v = mLedger->getNeededAccountStateHashes (4, &filter);
BOOST_FOREACH (uint256 const & h, v)
ret.push_back (std::make_pair (ripple::TMGetObjectByHash::otTRANSACTION_NODE, h));
ret.push_back (std::make_pair (protocol::TMGetObjectByHash::otTRANSACTION_NODE, h));
}
return ret;

2
src/cpp/ripple/ripple_InboundLedger.h
View File

@@ -79,7 +79,7 @@ public:
void noAwaitData ();
void checkLocal ();
typedef std::pair <ripple::TMGetObjectByHash::ObjectType, uint256> neededHash_t;
typedef std::pair <protocol::TMGetObjectByHash::ObjectType, uint256> neededHash_t;
std::vector<neededHash_t> getNeededHashes ();

12
src/cpp/ripple/ripple_InboundLedgers.cpp
View File

@@ -76,9 +76,9 @@ bool InboundLedgers::awaitLedgerData (uint256 const& ledgerHash)
}
void InboundLedgers::gotLedgerData (Job&, uint256 hash,
boost::shared_ptr<ripple::TMLedgerData> packet_ptr, boost::weak_ptr<Peer> wPeer)
boost::shared_ptr<protocol::TMLedgerData> packet_ptr, boost::weak_ptr<Peer> wPeer)
{
ripple::TMLedgerData& packet = *packet_ptr;
protocol::TMLedgerData& packet = *packet_ptr;
Peer::pointer peer = wPeer.lock ();
WriteLog (lsTRACE, InboundLedger) << "Got data (" << packet.nodes ().size () << ") for acquiring ledger: " << hash;
@@ -100,7 +100,7 @@ void InboundLedgers::gotLedgerData (Job&, uint256 hash,
if (!peer)
return;
if (packet.type () == ripple::liBASE)
if (packet.type () == protocol::liBASE)
{
if (packet.nodes_size () < 1)
{
@@ -139,7 +139,7 @@ void InboundLedgers::gotLedgerData (Job&, uint256 hash,
return;
}
if ((packet.type () == ripple::liTX_NODE) || (packet.type () == ripple::liAS_NODE))
if ((packet.type () == protocol::liTX_NODE) || (packet.type () == protocol::liAS_NODE))
{
std::list<SHAMapNode> nodeIDs;
std::list< Blob > nodeData;
@@ -153,7 +153,7 @@ void InboundLedgers::gotLedgerData (Job&, uint256 hash,
for (int i = 0; i < packet.nodes ().size (); ++i)
{
const ripple::TMLedgerNode& node = packet.nodes (i);
const protocol::TMLedgerNode& node = packet.nodes (i);
if (!node.has_nodeid () || !node.has_nodedata ())
{
@@ -168,7 +168,7 @@ void InboundLedgers::gotLedgerData (Job&, uint256 hash,
SHAMapAddNode ret;
if (packet.type () == ripple::liTX_NODE)
if (packet.type () == protocol::liTX_NODE)
ledger->takeTxNode (nodeIDs, nodeData, ret);
else
ledger->takeAsNode (nodeIDs, nodeData, ret);

2
src/cpp/ripple/ripple_InboundLedgers.h
View File

@@ -41,7 +41,7 @@ public:
//
void gotLedgerData (Job&,
LedgerHash hash,
boost::shared_ptr <ripple::TMLedgerData> packet,
boost::shared_ptr <protocol::TMLedgerData> packet,
boost::weak_ptr<Peer> peer);
int getFetchCount (int& timeoutCount);

44
src/cpp/ripple/ripple_LedgerConsensus.cpp
View File

@@ -82,11 +82,11 @@ void LedgerConsensus::checkOurValidation ()
theApp->getHashRouter ().addSuppression (signingHash);
theApp->getValidations ().addValidation (v, "localMissing");
Blob validation = v->getSigned ();
ripple::TMValidation val;
protocol::TMValidation val;
val.set_validation (&validation[0], validation.size ());
#if 0
theApp->getPeers ().relayMessage (NULL,
boost::make_shared<PackedMessage> (val, ripple::mtVALIDATION));
boost::make_shared<PackedMessage> (val, protocol::mtVALIDATION));
#endif
theApp->getOPs ().setLastValidation (v);
WriteLog (lsWARNING, LedgerConsensus) << "Sending partial validation";
@@ -378,10 +378,10 @@ void LedgerConsensus::mapComplete (uint256 const& hash, SHAMap::ref map, bool ac
void LedgerConsensus::sendHaveTxSet (uint256 const& hash, bool direct)
{
ripple::TMHaveTransactionSet msg;
protocol::TMHaveTransactionSet msg;
msg.set_hash (hash.begin (), 256 / 8);
msg.set_status (direct ? ripple::tsHAVE : ripple::tsCAN_GET);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (msg, ripple::mtHAVE_SET);
msg.set_status (direct ? protocol::tsHAVE : protocol::tsCAN_GET);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (msg, protocol::mtHAVE_SET);
theApp->getPeers ().relayMessage (NULL, packet);
}
@@ -396,13 +396,13 @@ void LedgerConsensus::adjustCount (SHAMap::ref map, const std::vector<uint160>&
}
}
void LedgerConsensus::statusChange (ripple::NodeEvent event, Ledger& ledger)
void LedgerConsensus::statusChange (protocol::NodeEvent event, Ledger& ledger)
{
// Send a node status change message to our peers
ripple::TMStatusChange s;
protocol::TMStatusChange s;
if (!mHaveCorrectLCL)
s.set_newevent (ripple::neLOST_SYNC);
s.set_newevent (protocol::neLOST_SYNC);
else
s.set_newevent (event);
@@ -418,7 +418,7 @@ void LedgerConsensus::statusChange (ripple::NodeEvent event, Ledger& ledger)
s.set_firstseq (uMin);
s.set_lastseq (uMax);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (s, ripple::mtSTATUS_CHANGE);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (s, protocol::mtSTATUS_CHANGE);
theApp->getPeers ().relayMessage (NULL, packet);
WriteLog (lsTRACE, LedgerConsensus) << "send status change to peer";
}
@@ -468,7 +468,7 @@ void LedgerConsensus::closeLedger ()
mConsensusStartTime = boost::posix_time::microsec_clock::universal_time ();
mCloseTime = theApp->getOPs ().getCloseTimeNC ();
theApp->getOPs ().setLastCloseTime (mCloseTime);
statusChange (ripple::neCLOSING_LEDGER, *mPreviousLedger);
statusChange (protocol::neCLOSING_LEDGER, *mPreviousLedger);
takeInitialPosition (*theApp->getLedgerMaster ().closeLedger (true));
}
@@ -803,7 +803,7 @@ void LedgerConsensus::propose ()
{
WriteLog (lsTRACE, LedgerConsensus) << "We propose: " <<
(mOurPosition->isBowOut () ? std::string ("bowOut") : mOurPosition->getCurrentHash ().GetHex ());
ripple::TMProposeSet prop;
protocol::TMProposeSet prop;
prop.set_currenttxhash (mOurPosition->getCurrentHash ().begin (), 256 / 8);
prop.set_previousledger (mOurPosition->getPrevLedger ().begin (), 256 / 8);
@@ -815,7 +815,7 @@ void LedgerConsensus::propose ()
prop.set_nodepubkey (&pubKey[0], pubKey.size ());
prop.set_signature (&sig[0], sig.size ());
theApp->getPeers ().relayMessage (NULL,
boost::make_shared<PackedMessage> (prop, ripple::mtPROPOSE_LEDGER));
boost::make_shared<PackedMessage> (prop, protocol::mtPROPOSE_LEDGER));
}
void LedgerConsensus::addDisputedTransaction (uint256 const& txID, Blob const& tx)
@@ -851,11 +851,11 @@ void LedgerConsensus::addDisputedTransaction (uint256 const& txID, Blob const& t
if (theApp->getHashRouter ().setFlag (txID, SF_RELAYED))
{
ripple::TMTransaction msg;
protocol::TMTransaction msg;
msg.set_rawtransaction (& (tx.front ()), tx.size ());
msg.set_status (ripple::tsNEW);
msg.set_status (protocol::tsNEW);
msg.set_receivetimestamp (theApp->getOPs ().getNetworkTimeNC ());
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (msg, ripple::mtTRANSACTION);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (msg, protocol::mtTRANSACTION);
theApp->getPeers ().relayMessage (NULL, packet);
}
}
@@ -919,9 +919,9 @@ bool LedgerConsensus::peerPosition (LedgerProposal::ref newPosition)
return true;
}
bool LedgerConsensus::peerHasSet (Peer::ref peer, uint256 const& hashSet, ripple::TxSetStatus status)
bool LedgerConsensus::peerHasSet (Peer::ref peer, uint256 const& hashSet, protocol::TxSetStatus status)
{
if (status != ripple::tsHAVE) // Indirect requests are for future support
if (status != protocol::tsHAVE) // Indirect requests are for future support
return true;
std::vector< boost::weak_ptr<Peer> >& set = mPeerData[hashSet];
@@ -1015,14 +1015,14 @@ void LedgerConsensus::playbackProposals ()
if (relay && theApp->getHashRouter ().swapSet (proposal.getSuppress (), set, SF_RELAYED))
{
WriteLog (lsDEBUG, LedgerConsensus) << "Stored proposal delayed relay";
ripple::TMProposeSet set;
protocol::TMProposeSet set;
set.set_proposeseq
set.set_currenttxhash (, 256 / 8);
previousledger
closetime
nodepubkey
signature
PackedMessage::pointer message = boost::make_shared<PackedMessage> (set, ripple::mtPROPOSE_LEDGER);
PackedMessage::pointer message = boost::make_shared<PackedMessage> (set, protocol::mtPROPOSE_LEDGER);
theApp->getPeers ().relayMessageBut (peers, message);
}
@@ -1241,7 +1241,7 @@ void LedgerConsensus::accept (SHAMap::ref set, LoadEvent::pointer)
WriteLog (lsTRACE, LedgerConsensus) << p;
}
statusChange (ripple::neACCEPTED_LEDGER, *newLCL);
statusChange (protocol::neACCEPTED_LEDGER, *newLCL);
if (mValidating && !mConsensusFail)
{
@@ -1262,10 +1262,10 @@ void LedgerConsensus::accept (SHAMap::ref set, LoadEvent::pointer)
theApp->getValidations ().addValidation (v, "local");
theApp->getOPs ().setLastValidation (v);
Blob validation = v->getSigned ();
ripple::TMValidation val;
protocol::TMValidation val;
val.set_validation (&validation[0], validation.size ());
int j = theApp->getPeers ().relayMessage (NULL,
boost::make_shared<PackedMessage> (val, ripple::mtVALIDATION));
boost::make_shared<PackedMessage> (val, protocol::mtVALIDATION));
WriteLog (lsINFO, LedgerConsensus) << "CNF Val " << newLCLHash << " to " << j << " peers";
}
else

4
src/cpp/ripple/ripple_LedgerConsensus.h
View File

@@ -58,7 +58,7 @@ public:
bool peerPosition (LedgerProposal::ref);
bool peerHasSet (Peer::ref peer, uint256 const & set, ripple::TxSetStatus status);
bool peerHasSet (Peer::ref peer, uint256 const & set, protocol::TxSetStatus status);
SHAMapAddNode peerGaveNodes (Peer::ref peer, uint256 const & setHash,
const std::list<SHAMapNode>& nodeIDs, const std::list< Blob >& nodeData);
@@ -95,7 +95,7 @@ private:
uint32 roundCloseTime (uint32 closeTime);
// manipulating our own position
void statusChange (ripple::NodeEvent, Ledger & ledger);
void statusChange (protocol::NodeEvent, Ledger & ledger);
void takeInitialPosition (Ledger & initialLedger);
void updateOurPositions ();
void playbackProposals ();

288
src/cpp/ripple/ripple_Peer.cpp
View File

@@ -139,8 +139,8 @@ private:
std::vector<uint8_t> mReadbuf;
std::list<PackedMessage::pointer> mSendQ;
PackedMessage::pointer mSendingPacket;
ripple::TMStatusChange mLastStatus;
ripple::TMHello mHello;
protocol::TMStatusChange mLastStatus;
protocol::TMHello mHello;
private:
void handleShutdown (const boost::system::error_code & error)
@@ -163,33 +163,33 @@ private:
void sendHello ();
void recvHello (ripple::TMHello & packet);
void recvTransaction (ripple::TMTransaction & packet, ScopedLock & MasterLockHolder);
void recvValidation (const boost::shared_ptr<ripple::TMValidation>& packet, ScopedLock & MasterLockHolder);
void recvGetValidation (ripple::TMGetValidations & packet);
void recvContact (ripple::TMContact & packet);
void recvGetContacts (ripple::TMGetContacts & packet);
void recvGetPeers (ripple::TMGetPeers & packet, ScopedLock & MasterLockHolder);
void recvPeers (ripple::TMPeers & packet);
void recvGetObjectByHash (const boost::shared_ptr<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, ScopedLock & MasterLockHolder);
void recvLedger (const boost::shared_ptr<ripple::TMLedgerData>& packet, ScopedLock & MasterLockHolder);
void recvStatus (ripple::TMStatusChange & packet);
void recvPropose (const boost::shared_ptr<ripple::TMProposeSet>& packet);
void recvHaveTxSet (ripple::TMHaveTransactionSet & packet);
void recvProofWork (ripple::TMProofWork & packet);
void recvHello (protocol::TMHello & packet);
void recvTransaction (protocol::TMTransaction & packet, ScopedLock & MasterLockHolder);
void recvValidation (const boost::shared_ptr<protocol::TMValidation>& packet, ScopedLock & MasterLockHolder);
void recvGetValidation (protocol::TMGetValidations & packet);
void recvContact (protocol::TMContact & packet);
void recvGetContacts (protocol::TMGetContacts & packet);
void recvGetPeers (protocol::TMGetPeers & packet, ScopedLock & MasterLockHolder);
void recvPeers (protocol::TMPeers & packet);
void recvGetObjectByHash (const boost::shared_ptr<protocol::TMGetObjectByHash>& packet);
void recvPing (protocol::TMPing & packet);
void recvErrorMessage (protocol::TMErrorMsg & packet);
void recvSearchTransaction (protocol::TMSearchTransaction & packet);
void recvGetAccount (protocol::TMGetAccount & packet);
void recvAccount (protocol::TMAccount & packet);
void recvGetLedger (protocol::TMGetLedger & packet, ScopedLock & MasterLockHolder);
void recvLedger (const boost::shared_ptr<protocol::TMLedgerData>& packet, ScopedLock & MasterLockHolder);
void recvStatus (protocol::TMStatusChange & packet);
void recvPropose (const boost::shared_ptr<protocol::TMProposeSet>& packet);
void recvHaveTxSet (protocol::TMHaveTransactionSet & packet);
void recvProofWork (protocol::TMProofWork & packet);
void getSessionCookie (std::string & strDst);
void addLedger (uint256 const & ledger);
void addTxSet (uint256 const & TxSet);
void doFetchPack (const boost::shared_ptr<ripple::TMGetObjectByHash>& packet);
void doFetchPack (const boost::shared_ptr<protocol::TMGetObjectByHash>& packet);
// VFALCO NOTE why is this a static member instead of a regular member?
static void doProofOfWork (Job&, boost::weak_ptr <Peer>, ProofOfWork::pointer);
@@ -325,9 +325,9 @@ void PeerImp::handlePingTimer (const boost::system::error_code& ecResult)
{
// idle->pingsent
mActive = 1;
ripple::TMPing packet;
packet.set_type (ripple::TMPing::ptPING);
sendPacket (boost::make_shared<PackedMessage> (packet, ripple::mtPING), true);
protocol::TMPing packet;
packet.set_type (protocol::TMPing::ptPING);
sendPacket (boost::make_shared<PackedMessage> (packet, protocol::mtPING), true);
}
else // active->idle
mActive = 0;
@@ -650,7 +650,7 @@ void PeerImp::processReadBuffer ()
ScopedLock sl (theApp->getMasterLock ());
// If connected and get a mtHELLO or if not connected and get a non-mtHELLO, wrong message was sent.
if (mHelloed == (type == ripple::mtHELLO))
if (mHelloed == (type == protocol::mtHELLO))
{
WriteLog (lsWARNING, Peer) << "Wrong message type: " << type;
detach ("prb1", true);
@@ -659,10 +659,10 @@ void PeerImp::processReadBuffer ()
{
switch (type)
{
case ripple::mtHELLO:
case protocol::mtHELLO:
{
event->reName ("PeerImp::hello");
ripple::TMHello msg;
protocol::TMHello msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvHello (msg);
@@ -671,10 +671,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtERROR_MSG:
case protocol::mtERROR_MSG:
{
event->reName ("PeerImp::errormessage");
ripple::TMErrorMsg msg;
protocol::TMErrorMsg msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvErrorMessage (msg);
@@ -683,10 +683,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtPING:
case protocol::mtPING:
{
event->reName ("PeerImp::ping");
ripple::TMPing msg;
protocol::TMPing msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvPing (msg);
@@ -695,10 +695,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtGET_CONTACTS:
case protocol::mtGET_CONTACTS:
{
event->reName ("PeerImp::getcontacts");
ripple::TMGetContacts msg;
protocol::TMGetContacts msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvGetContacts (msg);
@@ -707,10 +707,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtCONTACT:
case protocol::mtCONTACT:
{
event->reName ("PeerImp::contact");
ripple::TMContact msg;
protocol::TMContact msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvContact (msg);
@@ -719,10 +719,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtGET_PEERS:
case protocol::mtGET_PEERS:
{
event->reName ("PeerImp::getpeers");
ripple::TMGetPeers msg;
protocol::TMGetPeers msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvGetPeers (msg, sl);
@@ -731,10 +731,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtPEERS:
case protocol::mtPEERS:
{
event->reName ("PeerImp::peers");
ripple::TMPeers msg;
protocol::TMPeers msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvPeers (msg);
@@ -743,10 +743,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtSEARCH_TRANSACTION:
case protocol::mtSEARCH_TRANSACTION:
{
event->reName ("PeerImp::searchtransaction");
ripple::TMSearchTransaction msg;
protocol::TMSearchTransaction msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvSearchTransaction (msg);
@@ -755,10 +755,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtGET_ACCOUNT:
case protocol::mtGET_ACCOUNT:
{
event->reName ("PeerImp::getaccount");
ripple::TMGetAccount msg;
protocol::TMGetAccount msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvGetAccount (msg);
@@ -767,10 +767,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtACCOUNT:
case protocol::mtACCOUNT:
{
event->reName ("PeerImp::account");
ripple::TMAccount msg;
protocol::TMAccount msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvAccount (msg);
@@ -779,10 +779,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtTRANSACTION:
case protocol::mtTRANSACTION:
{
event->reName ("PeerImp::transaction");
ripple::TMTransaction msg;
protocol::TMTransaction msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvTransaction (msg, sl);
@@ -791,10 +791,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtSTATUS_CHANGE:
case protocol::mtSTATUS_CHANGE:
{
event->reName ("PeerImp::statuschange");
ripple::TMStatusChange msg;
protocol::TMStatusChange msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvStatus (msg);
@@ -803,10 +803,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtPROPOSE_LEDGER:
case protocol::mtPROPOSE_LEDGER:
{
event->reName ("PeerImp::propose");
boost::shared_ptr<ripple::TMProposeSet> msg = boost::make_shared<ripple::TMProposeSet> ();
boost::shared_ptr<protocol::TMProposeSet> msg = boost::make_shared<protocol::TMProposeSet> ();
if (msg->ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvPropose (msg);
@@ -815,10 +815,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtGET_LEDGER:
case protocol::mtGET_LEDGER:
{
event->reName ("PeerImp::getledger");
ripple::TMGetLedger msg;
protocol::TMGetLedger msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvGetLedger (msg, sl);
@@ -827,10 +827,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtLEDGER_DATA:
case protocol::mtLEDGER_DATA:
{
event->reName ("PeerImp::ledgerdata");
boost::shared_ptr<ripple::TMLedgerData> msg = boost::make_shared<ripple::TMLedgerData> ();
boost::shared_ptr<protocol::TMLedgerData> msg = boost::make_shared<protocol::TMLedgerData> ();
if (msg->ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvLedger (msg, sl);
@@ -839,10 +839,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtHAVE_SET:
case protocol::mtHAVE_SET:
{
event->reName ("PeerImp::haveset");
ripple::TMHaveTransactionSet msg;
protocol::TMHaveTransactionSet msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvHaveTxSet (msg);
@@ -851,10 +851,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtVALIDATION:
case protocol::mtVALIDATION:
{
event->reName ("PeerImp::validation");
boost::shared_ptr<ripple::TMValidation> msg = boost::make_shared<ripple::TMValidation> ();
boost::shared_ptr<protocol::TMValidation> msg = boost::make_shared<protocol::TMValidation> ();
if (msg->ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvValidation (msg, sl);
@@ -864,9 +864,9 @@ void PeerImp::processReadBuffer ()
break;
#if 0
case ripple::mtGET_VALIDATION:
case protocol::mtGET_VALIDATION:
{
ripple::TM msg;
protocol::TM msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recv (msg);
@@ -877,10 +877,10 @@ void PeerImp::processReadBuffer ()
#endif
case ripple::mtGET_OBJECTS:
case protocol::mtGET_OBJECTS:
{
event->reName ("PeerImp::getobjects");
boost::shared_ptr<ripple::TMGetObjectByHash> msg = boost::make_shared<ripple::TMGetObjectByHash> ();
boost::shared_ptr<protocol::TMGetObjectByHash> msg = boost::make_shared<protocol::TMGetObjectByHash> ();
if (msg->ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvGetObjectByHash (msg);
@@ -889,10 +889,10 @@ void PeerImp::processReadBuffer ()
}
break;
case ripple::mtPROOFOFWORK:
case protocol::mtPROOFOFWORK:
{
event->reName ("PeerImp::proofofwork");
ripple::TMProofWork msg;
protocol::TMProofWork msg;
if (msg.ParseFromArray (&mReadbuf[PackedMessage::kHeaderBytes], mReadbuf.size () - PackedMessage::kHeaderBytes))
recvProofWork (msg);
@@ -910,7 +910,7 @@ void PeerImp::processReadBuffer ()
}
}
void PeerImp::recvHello (ripple::TMHello& packet)
void PeerImp::recvHello (protocol::TMHello& packet)
{
bool bDetach = true;
@@ -1094,7 +1094,7 @@ static void checkTransaction (Job&, int flags, SerializedTransaction::pointer st
#endif
}
void PeerImp::recvTransaction (ripple::TMTransaction& packet, ScopedLock& MasterLockHolder)
void PeerImp::recvTransaction (protocol::TMTransaction& packet, ScopedLock& MasterLockHolder)
{
MasterLockHolder.unlock ();
Transaction::pointer tx;
@@ -1147,7 +1147,7 @@ void PeerImp::recvTransaction (ripple::TMTransaction& packet, ScopedLock& Master
}
// Called from our JobQueue
static void checkPropose (Job& job, boost::shared_ptr<ripple::TMProposeSet> packet,
static void checkPropose (Job& job, boost::shared_ptr<protocol::TMProposeSet> packet,
LedgerProposal::pointer proposal, uint256 consensusLCL, RippleAddress nodePublic, boost::weak_ptr<Peer> peer)
{
bool sigGood = false;
@@ -1156,7 +1156,7 @@ static void checkPropose (Job& job, boost::shared_ptr<ripple::TMProposeSet> pack
WriteLog (lsTRACE, Peer) << "Checking " << (isTrusted ? "trusted" : "UNtrusted") << " proposal";
assert (packet);
ripple::TMProposeSet& set = *packet;
protocol::TMProposeSet& set = *packet;
uint256 prevLedger;
@@ -1199,17 +1199,17 @@ static void checkPropose (Job& job, boost::shared_ptr<ripple::TMProposeSet> pack
WriteLog (lsTRACE, Peer) << "relaying untrusted proposal";
std::set<uint64> peers;
theApp->getHashRouter ().swapSet (proposal->getHashRouter (), peers, SF_RELAYED);
PackedMessage::pointer message = boost::make_shared<PackedMessage> (set, ripple::mtPROPOSE_LEDGER);
PackedMessage::pointer message = boost::make_shared<PackedMessage> (set, protocol::mtPROPOSE_LEDGER);
theApp->getPeers ().relayMessageBut (peers, message);
}
else
WriteLog (lsDEBUG, Peer) << "Not relaying untrusted proposal";
}
void PeerImp::recvPropose (const boost::shared_ptr<ripple::TMProposeSet>& packet)
void PeerImp::recvPropose (const boost::shared_ptr<protocol::TMProposeSet>& packet)
{
assert (packet);
ripple::TMProposeSet& set = *packet;
protocol::TMProposeSet& set = *packet;
if ((set.currenttxhash ().size () != 32) || (set.nodepubkey ().size () < 28) ||
(set.signature ().size () < 56) || (set.nodepubkey ().size () > 128) || (set.signature ().size () > 128))
@@ -1277,7 +1277,7 @@ void PeerImp::recvPropose (const boost::shared_ptr<ripple::TMProposeSet>& packet
mNodePublic, boost::weak_ptr<Peer> (shared_from_this ())));
}
void PeerImp::recvHaveTxSet (ripple::TMHaveTransactionSet& packet)
void PeerImp::recvHaveTxSet (protocol::TMHaveTransactionSet& packet)
{
uint256 hashes;
@@ -1290,7 +1290,7 @@ void PeerImp::recvHaveTxSet (ripple::TMHaveTransactionSet& packet)
uint256 hash;
memcpy (hash.begin (), packet.hash ().data (), 32);
if (packet.status () == ripple::tsHAVE)
if (packet.status () == protocol::tsHAVE)
addTxSet (hash);
if (!theApp->getOPs ().hasTXSet (shared_from_this (), hash, packet.status ()))
@@ -1298,7 +1298,7 @@ void PeerImp::recvHaveTxSet (ripple::TMHaveTransactionSet& packet)
}
static void checkValidation (Job&, SerializedValidation::pointer val, uint256 signingHash,
bool isTrusted, bool isCluster, boost::shared_ptr<ripple::TMValidation> packet, boost::weak_ptr<Peer> peer)
bool isTrusted, bool isCluster, boost::shared_ptr<protocol::TMValidation> packet, boost::weak_ptr<Peer> peer)
{
#ifndef TRUST_NETWORK
@@ -1325,7 +1325,7 @@ static void checkValidation (Job&, SerializedValidation::pointer val, uint256 si
if (theApp->getOPs ().recvValidation (val, source) &&
theApp->getHashRouter ().swapSet (signingHash, peers, SF_RELAYED))
{
PackedMessage::pointer message = boost::make_shared<PackedMessage> (*packet, ripple::mtVALIDATION);
PackedMessage::pointer message = boost::make_shared<PackedMessage> (*packet, protocol::mtVALIDATION);
theApp->getPeers ().relayMessageBut (peers, message);
}
}
@@ -1340,7 +1340,7 @@ static void checkValidation (Job&, SerializedValidation::pointer val, uint256 si
#endif
}
void PeerImp::recvValidation (const boost::shared_ptr<ripple::TMValidation>& packet, ScopedLock& MasterLockHolder)
void PeerImp::recvValidation (const boost::shared_ptr<protocol::TMValidation>& packet, ScopedLock& MasterLockHolder)
{
MasterLockHolder.unlock ();
@@ -1387,22 +1387,22 @@ void PeerImp::recvValidation (const boost::shared_ptr<ripple::TMValidation>& pac
#endif
}
void PeerImp::recvGetValidation (ripple::TMGetValidations& packet)
void PeerImp::recvGetValidation (protocol::TMGetValidations& packet)
{
}
void PeerImp::recvContact (ripple::TMContact& packet)
void PeerImp::recvContact (protocol::TMContact& packet)
{
}
void PeerImp::recvGetContacts (ripple::TMGetContacts& packet)
void PeerImp::recvGetContacts (protocol::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 PeerImp::recvGetPeers (ripple::TMGetPeers& packet, ScopedLock& MasterLockHolder)
void PeerImp::recvGetPeers (protocol::TMGetPeers& packet, ScopedLock& MasterLockHolder)
{
MasterLockHolder.unlock ();
std::vector<std::string> addrs;
@@ -1411,7 +1411,7 @@ void PeerImp::recvGetPeers (ripple::TMGetPeers& packet, ScopedLock& MasterLockHo
if (!addrs.empty ())
{
ripple::TMPeers peers;
protocol::TMPeers peers;
for (unsigned int n = 0; n < addrs.size (); n++)
{
@@ -1421,20 +1421,20 @@ void PeerImp::recvGetPeers (ripple::TMGetPeers& packet, ScopedLock& MasterLockHo
splitIpPort (addrs[n], strIP, iPort);
// XXX This should also ipv6
ripple::TMIPv4EndPoint* addr = peers.add_nodes ();
protocol::TMIPv4EndPoint* addr = peers.add_nodes ();
addr->set_ipv4 (inet_addr (strIP.c_str ()));
addr->set_ipv4port (iPort);
//WriteLog (lsINFO, Peer) << "Peer: Teaching: " << ADDRESS(this) << ": " << n << ": " << strIP << " " << iPort;
}
PackedMessage::pointer message = boost::make_shared<PackedMessage> (peers, ripple::mtPEERS);
PackedMessage::pointer message = boost::make_shared<PackedMessage> (peers, protocol::mtPEERS);
sendPacket (message, true);
}
}
// TODO: filter out all the LAN peers
void PeerImp::recvPeers (ripple::TMPeers& packet)
void PeerImp::recvPeers (protocol::TMPeers& packet)
{
for (int i = 0; i < packet.nodes ().size (); ++i)
{
@@ -1454,20 +1454,20 @@ void PeerImp::recvPeers (ripple::TMPeers& packet)
}
}
void PeerImp::recvGetObjectByHash (const boost::shared_ptr<ripple::TMGetObjectByHash>& ptr)
void PeerImp::recvGetObjectByHash (const boost::shared_ptr<protocol::TMGetObjectByHash>& ptr)
{
ripple::TMGetObjectByHash& packet = *ptr;
protocol::TMGetObjectByHash& packet = *ptr;
if (packet.query ())
{
// this is a query
if (packet.type () == ripple::TMGetObjectByHash::otFETCH_PACK)
if (packet.type () == protocol::TMGetObjectByHash::otFETCH_PACK)
{
doFetchPack (ptr);
return;
}
ripple::TMGetObjectByHash reply;
protocol::TMGetObjectByHash reply;
reply.set_query (false);
@@ -1483,7 +1483,7 @@ void PeerImp::recvGetObjectByHash (const boost::shared_ptr<ripple::TMGetObjectBy
for (int i = 0; i < packet.objects_size (); ++i)
{
uint256 hash;
const ripple::TMIndexedObject& obj = packet.objects (i);
const protocol::TMIndexedObject& obj = packet.objects (i);
if (obj.has_hash () && (obj.hash ().size () == (256 / 8)))
{
@@ -1492,7 +1492,7 @@ void PeerImp::recvGetObjectByHash (const boost::shared_ptr<ripple::TMGetObjectBy
if (hObj)
{
ripple::TMIndexedObject& newObj = *reply.add_objects ();
protocol::TMIndexedObject& newObj = *reply.add_objects ();
newObj.set_hash (hash.begin (), hash.size ());
newObj.set_data (&hObj->getData ().front (), hObj->getData ().size ());
@@ -1507,7 +1507,7 @@ void PeerImp::recvGetObjectByHash (const boost::shared_ptr<ripple::TMGetObjectBy
WriteLog (lsTRACE, Peer) << "GetObjByHash had " << reply.objects_size () << " of " << packet.objects_size ()
<< " for " << getIP ();
sendPacket (boost::make_shared<PackedMessage> (reply, ripple::mtGET_OBJECTS), true);
sendPacket (boost::make_shared<PackedMessage> (reply, protocol::mtGET_OBJECTS), true);
}
else
{
@@ -1518,7 +1518,7 @@ void PeerImp::recvGetObjectByHash (const boost::shared_ptr<ripple::TMGetObjectBy
for (int i = 0; i < packet.objects_size (); ++i)
{
const ripple::TMIndexedObject& obj = packet.objects (i);
const protocol::TMIndexedObject& obj = packet.objects (i);
if (obj.has_hash () && (obj.hash ().size () == (256 / 8)))
{
@@ -1555,41 +1555,41 @@ void PeerImp::recvGetObjectByHash (const boost::shared_ptr<ripple::TMGetObjectBy
CondLog (pLDo && (pLSeq != 0), lsDEBUG, Peer) << "Received partial fetch pack for " << pLSeq;
if (packet.type () == ripple::TMGetObjectByHash::otFETCH_PACK)
if (packet.type () == protocol::TMGetObjectByHash::otFETCH_PACK)
theApp->getOPs ().gotFetchPack (progress, pLSeq);
}
}
void PeerImp::recvPing (ripple::TMPing& packet)
void PeerImp::recvPing (protocol::TMPing& packet)
{
if (packet.type () == ripple::TMPing::ptPING)
if (packet.type () == protocol::TMPing::ptPING)
{
packet.set_type (ripple::TMPing::ptPONG);
sendPacket (boost::make_shared<PackedMessage> (packet, ripple::mtPING), true);
packet.set_type (protocol::TMPing::ptPONG);
sendPacket (boost::make_shared<PackedMessage> (packet, protocol::mtPING), true);
}
else if (packet.type () == ripple::TMPing::ptPONG)
else if (packet.type () == protocol::TMPing::ptPONG)
{
mActive = 2;
}
}
void PeerImp::recvErrorMessage (ripple::TMErrorMsg& packet)
void PeerImp::recvErrorMessage (protocol::TMErrorMsg& packet)
{
}
void PeerImp::recvSearchTransaction (ripple::TMSearchTransaction& packet)
void PeerImp::recvSearchTransaction (protocol::TMSearchTransaction& packet)
{
}
void PeerImp::recvGetAccount (ripple::TMGetAccount& packet)
void PeerImp::recvGetAccount (protocol::TMGetAccount& packet)
{
}
void PeerImp::recvAccount (ripple::TMAccount& packet)
void PeerImp::recvAccount (protocol::TMAccount& packet)
{
}
void PeerImp::recvProofWork (ripple::TMProofWork& packet)
void PeerImp::recvProofWork (protocol::TMProofWork& packet)
{
if (packet.has_response ())
{
@@ -1660,7 +1660,7 @@ void PeerImp::recvProofWork (ripple::TMProofWork& packet)
WriteLog (lsINFO, Peer) << "Received in valid proof of work object from peer";
}
void PeerImp::recvStatus (ripple::TMStatusChange& packet)
void PeerImp::recvStatus (protocol::TMStatusChange& packet)
{
WriteLog (lsTRACE, Peer) << "Received status change from peer " << getIP ();
@@ -1672,12 +1672,12 @@ void PeerImp::recvStatus (ripple::TMStatusChange& packet)
else
{
// preserve old status
ripple::NodeStatus status = mLastStatus.newstatus ();
protocol::NodeStatus status = mLastStatus.newstatus ();
mLastStatus = packet;
packet.set_newstatus (status);
}
if (packet.newevent () == ripple::neLOST_SYNC)
if (packet.newevent () == protocol::neLOST_SYNC)
{
if (!mClosedLedgerHash.isZero ())
{
@@ -1716,10 +1716,10 @@ void PeerImp::recvStatus (ripple::TMStatusChange& packet)
mMaxLedger = packet.lastseq ();
}
void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLockHolder)
void PeerImp::recvGetLedger (protocol::TMGetLedger& packet, ScopedLock& MasterLockHolder)
{
SHAMap::pointer map;
ripple::TMLedgerData reply;
protocol::TMLedgerData reply;
bool fatLeaves = true, fatRoot = false;
if (packet.has_requestcookie ())
@@ -1727,7 +1727,7 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
std::string logMe;
if (packet.itype () == ripple::liTS_CANDIDATE)
if (packet.itype () == protocol::liTS_CANDIDATE)
{
// Request is for a transaction candidate set
WriteLog (lsDEBUG, Peer) << "Received request for TX candidate set data " << getIP ();
@@ -1764,7 +1764,7 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
Peer::ref selectedPeer = usablePeers[rand () % usablePeers.size ()];
packet.set_requestcookie (getPeerId ());
selectedPeer->sendPacket (boost::make_shared<PackedMessage> (packet, ripple::mtGET_LEDGER), false);
selectedPeer->sendPacket (boost::make_shared<PackedMessage> (packet, protocol::mtGET_LEDGER), false);
return;
}
@@ -1775,7 +1775,7 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
reply.set_ledgerseq (0);
reply.set_ledgerhash (txHash.begin (), txHash.size ());
reply.set_type (ripple::liTS_CANDIDATE);
reply.set_type (protocol::liTS_CANDIDATE);
fatLeaves = false; // We'll already have most transactions
fatRoot = true; // Save a pass
}
@@ -1826,7 +1826,7 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
Peer::ref selectedPeer = usablePeers[rand () % usablePeers.size ()];
packet.set_requestcookie (getPeerId ());
selectedPeer->sendPacket (boost::make_shared<PackedMessage> (packet, ripple::mtGET_LEDGER), false);
selectedPeer->sendPacket (boost::make_shared<PackedMessage> (packet, protocol::mtGET_LEDGER), false);
WriteLog (lsDEBUG, Peer) << "Ledger request routed";
return;
}
@@ -1836,9 +1836,9 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
ledger = theApp->getLedgerMaster ().getLedgerBySeq (packet.ledgerseq ());
CondLog (!ledger, lsDEBUG, Peer) << "Don't have ledger " << packet.ledgerseq ();
}
else if (packet.has_ltype () && (packet.ltype () == ripple::ltCURRENT))
else if (packet.has_ltype () && (packet.ltype () == protocol::ltCURRENT))
ledger = theApp->getLedgerMaster ().getCurrentLedger ();
else if (packet.has_ltype () && (packet.ltype () == ripple::ltCLOSED) )
else if (packet.has_ltype () && (packet.ltype () == protocol::ltCLOSED) )
{
ledger = theApp->getLedgerMaster ().getClosedLedger ();
@@ -1878,7 +1878,7 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
reply.set_ledgerseq (ledger->getLedgerSeq ());
reply.set_type (packet.itype ());
if (packet.itype () == ripple::liBASE)
if (packet.itype () == protocol::liBASE)
{
// they want the ledger base data
WriteLog (lsTRACE, Peer) << "They want ledger base data";
@@ -1912,18 +1912,18 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
}
}
PackedMessage::pointer oPacket = boost::make_shared<PackedMessage> (reply, ripple::mtLEDGER_DATA);
PackedMessage::pointer oPacket = boost::make_shared<PackedMessage> (reply, protocol::mtLEDGER_DATA);
sendPacket (oPacket, true);
return;
}
if (packet.itype () == ripple::liTX_NODE)
if (packet.itype () == protocol::liTX_NODE)
{
map = ledger->peekTransactionMap ();
logMe += " TX:";
logMe += map->getHash ().GetHex ();
}
else if (packet.itype () == ripple::liAS_NODE)
else if (packet.itype () == protocol::liAS_NODE)
{
map = ledger->peekAccountStateMap ();
logMe += " AS:";
@@ -1968,7 +1968,7 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
{
Serializer nID (33);
nodeIDIterator->addIDRaw (nID);
ripple::TMLedgerNode* node = reply.add_nodes ();
protocol::TMLedgerNode* node = reply.add_nodes ();
node->set_nodeid (nID.getDataPtr (), nID.getLength ());
node->set_nodedata (&rawNodeIterator->front (), rawNodeIterator->size ());
}
@@ -1980,13 +1980,13 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
{
std::string info;
if (packet.itype () == ripple::liTS_CANDIDATE)
if (packet.itype () == protocol::liTS_CANDIDATE)
info = "TS candidate";
else if (packet.itype () == ripple::liBASE)
else if (packet.itype () == protocol::liBASE)
info = "Ledger base";
else if (packet.itype () == ripple::liTX_NODE)
else if (packet.itype () == protocol::liTX_NODE)
info = "TX node";
else if (packet.itype () == ripple::liAS_NODE)
else if (packet.itype () == protocol::liAS_NODE)
info = "AS node";
if (!packet.has_ledgerhash ())
@@ -1996,14 +1996,14 @@ void PeerImp::recvGetLedger (ripple::TMGetLedger& packet, ScopedLock& MasterLock
}
}
PackedMessage::pointer oPacket = boost::make_shared<PackedMessage> (reply, ripple::mtLEDGER_DATA);
PackedMessage::pointer oPacket = boost::make_shared<PackedMessage> (reply, protocol::mtLEDGER_DATA);
sendPacket (oPacket, true);
}
void PeerImp::recvLedger (const boost::shared_ptr<ripple::TMLedgerData>& packet_ptr, ScopedLock& MasterLockHolder)
void PeerImp::recvLedger (const boost::shared_ptr<protocol::TMLedgerData>& packet_ptr, ScopedLock& MasterLockHolder)
{
MasterLockHolder.unlock ();
ripple::TMLedgerData& packet = *packet_ptr;
protocol::TMLedgerData& packet = *packet_ptr;
if (packet.nodes ().size () <= 0)
{
@@ -2019,7 +2019,7 @@ void PeerImp::recvLedger (const boost::shared_ptr<ripple::TMLedgerData>& packet_
if (target)
{
packet.clear_requestcookie ();
target->sendPacket (boost::make_shared<PackedMessage> (packet, ripple::mtLEDGER_DATA), false);
target->sendPacket (boost::make_shared<PackedMessage> (packet, protocol::mtLEDGER_DATA), false);
}
else
{
@@ -2041,7 +2041,7 @@ void PeerImp::recvLedger (const boost::shared_ptr<ripple::TMLedgerData>& packet_
memcpy (hash.begin (), packet.ledgerhash ().data (), 32);
if (packet.type () == ripple::liTS_CANDIDATE)
if (packet.type () == protocol::liTS_CANDIDATE)
{
// got data for a candidate transaction set
std::list<SHAMapNode> nodeIDs;
@@ -2049,7 +2049,7 @@ void PeerImp::recvLedger (const boost::shared_ptr<ripple::TMLedgerData>& packet_
for (int i = 0; i < packet.nodes ().size (); ++i)
{
const ripple::TMLedgerNode& node = packet.nodes (i);
const protocol::TMLedgerNode& node = packet.nodes (i);
if (!node.has_nodeid () || !node.has_nodedata () || (node.nodeid ().size () != 33))
{
@@ -2168,7 +2168,7 @@ void PeerImp::sendHello ()
theApp->getLocalCredentials ().getNodePrivate ().signNodePrivate (mCookieHash, vchSig);
ripple::TMHello h;
protocol::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));
@@ -2190,18 +2190,18 @@ void PeerImp::sendHello ()
h.set_ledgerprevious (hash.begin (), hash.GetSerializeSize ());
}
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (h, ripple::mtHELLO);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (h, protocol::mtHELLO);
sendPacket (packet, true);
}
void PeerImp::sendGetPeers ()
{
// Ask peer for known other peers.
ripple::TMGetPeers getPeers;
protocol::TMGetPeers getPeers;
getPeers.set_doweneedthis (1);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (getPeers, ripple::mtGET_PEERS);
PackedMessage::pointer packet = boost::make_shared<PackedMessage> (getPeers, protocol::mtGET_PEERS);
sendPacket (packet, true);
}
@@ -2231,10 +2231,10 @@ void PeerImp::doProofOfWork (Job&, boost::weak_ptr <Peer> peer, ProofOfWork::poi
if (pptr)
{
ripple::TMProofWork reply;
protocol::TMProofWork reply;
reply.set_token (pow->getToken ());
reply.set_response (solution.begin (), solution.size ());
pptr->sendPacket (boost::make_shared<PackedMessage> (reply, ripple::mtPROOFOFWORK), false);
pptr->sendPacket (boost::make_shared<PackedMessage> (reply, protocol::mtPROOFOFWORK), false);
}
else
{
@@ -2243,7 +2243,7 @@ void PeerImp::doProofOfWork (Job&, boost::weak_ptr <Peer> peer, ProofOfWork::poi
}
}
void PeerImp::doFetchPack (const boost::shared_ptr<ripple::TMGetObjectByHash>& packet)
void PeerImp::doFetchPack (const boost::shared_ptr<protocol::TMGetObjectByHash>& packet)
{
if (theApp->getFeeTrack ().isLoaded ())
{
@@ -2332,23 +2332,23 @@ Json::Value PeerImp::getJson ()
{
switch (mLastStatus.newstatus ())
{
case ripple::nsCONNECTING:
case protocol::nsCONNECTING:
ret["status"] = "connecting";
break;
case ripple::nsCONNECTED:
case protocol::nsCONNECTED:
ret["status"] = "connected";
break;
case ripple::nsMONITORING:
case protocol::nsMONITORING:
ret["status"] = "monitoring";
break;
case ripple::nsVALIDATING:
case protocol::nsVALIDATING:
ret["status"] = "validating";
break;
case ripple::nsSHUTTING:
case protocol::nsSHUTTING:
ret["status"] = "shutting";
break;

4
src/cpp/ripple/ripple_PeerSet.h
View File

@@ -84,8 +84,8 @@ protected:
}
void invokeOnTimer ();
void sendRequest (const ripple::TMGetLedger& message);
void sendRequest (const ripple::TMGetLedger& message, Peer::ref peer);
void sendRequest (const protocol::TMGetLedger& message);
void sendRequest (const protocol::TMGetLedger& message, Peer::ref peer);
protected:
uint256 mHash;

12
src/cpp/ripple/ripple_TransactionAcquire.cpp
View File

@@ -112,12 +112,12 @@ void TransactionAcquire::trigger (Peer::ref peer)
if (!mHaveRoot)
{
WriteLog (lsTRACE, TransactionAcquire) << "TransactionAcquire::trigger " << (peer ? "havePeer" : "noPeer") << " no root";
ripple::TMGetLedger tmGL;
protocol::TMGetLedger tmGL;
tmGL.set_ledgerhash (mHash.begin (), mHash.size ());
tmGL.set_itype (ripple::liTS_CANDIDATE);
tmGL.set_itype (protocol::liTS_CANDIDATE);
if (getTimeouts () != 0)
tmGL.set_querytype (ripple::qtINDIRECT);
tmGL.set_querytype (protocol::qtINDIRECT);
* (tmGL.add_nodeids ()) = SHAMapNode ().getRawString ();
sendRequest (tmGL, peer);
@@ -140,12 +140,12 @@ void TransactionAcquire::trigger (Peer::ref peer)
return;
}
ripple::TMGetLedger tmGL;
protocol::TMGetLedger tmGL;
tmGL.set_ledgerhash (mHash.begin (), mHash.size ());
tmGL.set_itype (ripple::liTS_CANDIDATE);
tmGL.set_itype (protocol::liTS_CANDIDATE);
if (getTimeouts () != 0)
tmGL.set_querytype (ripple::qtINDIRECT);
tmGL.set_querytype (protocol::qtINDIRECT);
BOOST_FOREACH (SHAMapNode & it, nodeIDs)
* (tmGL.add_nodeids ()) = it.getRawString ();