ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-21 19:45: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) if (nextLedger)
{ {
ripple::TMGetObjectByHash tmBH; protocol::TMGetObjectByHash tmBH;
tmBH.set_type (ripple::TMGetObjectByHash::otFETCH_PACK); tmBH.set_type (protocol::TMGetObjectByHash::otFETCH_PACK);
tmBH.set_query (true); tmBH.set_query (true);
tmBH.set_seq (ledgerSeq); tmBH.set_seq (ledgerSeq);
tmBH.set_ledgerhash (ledgerHash.begin (), 32); tmBH.set_ledgerhash (ledgerHash.begin (), 32);
@@ -373,7 +373,7 @@ bool LedgerMaster::acquireMissingLedger (Ledger::ref origLedger, uint256 const&
if (target) 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); target->sendPacket (packet, false);
} }
else 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)) if (theApp->getHashRouter ().swapSet (txn->getID (), peers, SF_RELAYED))
{ {
ripple::TMTransaction tx; protocol::TMTransaction tx;
Serializer s; Serializer s;
dbtx->getSTransaction ()->add (s); dbtx->getSTransaction ()->add (s);
tx.set_rawtransaction (&s.getData ().front (), s.getLength ()); 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 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); 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)) if (theApp->getHashRouter ().swapSet (trans->getID (), peers, SF_RELAYED))
{ {
ripple::TMTransaction tx; protocol::TMTransaction tx;
Serializer s; Serializer s;
trans->getSTransaction ()->add (s); trans->getSTransaction ()->add (s);
tx.set_rawtransaction (&s.getData ().front (), s.getLength ()); 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 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); 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)); Ledger::pointer openLedger = boost::make_shared<Ledger> (false, boost::ref (*newLedger));
mLedgerMaster->switchLedgers (newLedger, openLedger); mLedgerMaster->switchLedgers (newLedger, openLedger);
ripple::TMStatusChange s; protocol::TMStatusChange s;
s.set_newevent (ripple::neSWITCHED_LEDGER); s.set_newevent (protocol::neSWITCHED_LEDGER);
s.set_ledgerseq (newLedger->getLedgerSeq ()); s.set_ledgerseq (newLedger->getLedgerSeq ());
s.set_networktime (theApp->getOPs ().getNetworkTimeNC ()); s.set_networktime (theApp->getOPs ().getNetworkTimeNC ());
uint256 hash = newLedger->getParentHash (); uint256 hash = newLedger->getParentHash ();
s.set_ledgerhashprevious (hash.begin (), hash.size ()); s.set_ledgerhashprevious (hash.begin (), hash.size ());
hash = newLedger->getHash (); hash = newLedger->getHash ();
s.set_ledgerhash (hash.begin (), hash.size ()); 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); theApp->getPeers ().relayMessage (NULL, packet);
} }
@@ -935,7 +935,7 @@ uint256 NetworkOPs::getConsensusLCL ()
} }
void NetworkOPs::processTrustedProposal (LedgerProposal::pointer proposal, 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 ()); boost::recursive_mutex::scoped_lock sl (theApp->getMasterLock ());
@@ -975,7 +975,7 @@ void NetworkOPs::processTrustedProposal (LedgerProposal::pointer proposal,
{ {
std::set<uint64> peers; std::set<uint64> peers;
theApp->getHashRouter ().swapSet (proposal->getHashRouter (), peers, SF_RELAYED); 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); theApp->getPeers ().relayMessageBut (peers, message);
} }
else else
@@ -1028,7 +1028,7 @@ SHAMapAddNode NetworkOPs::gotTXData (const boost::shared_ptr<Peer>& peer, uint25
return mConsensus->peerGaveNodes (peer, hash, nodeIDs, nodeData); 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 ()) if (!haveConsensusObject ())
{ {
@@ -2130,17 +2130,17 @@ void NetworkOPs::getBookPage (Ledger::pointer lpLedger, const uint160& uTakerPay
// jvResult["nodes"] = Json::Value(Json::arrayValue); // 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) const uint256& hash, const Blob& blob)
{ {
ripple::TMIndexedObject& newObj = * (reply->add_objects ()); protocol::TMIndexedObject& newObj = * (reply->add_objects ());
newObj.set_ledgerseq (ledgerSeq); newObj.set_ledgerseq (ledgerSeq);
newObj.set_hash (hash.begin (), 256 / 8); newObj.set_hash (hash.begin (), 256 / 8);
newObj.set_data (&blob[0], blob.size ()); newObj.set_data (&blob[0], blob.size ());
} }
void NetworkOPs::makeFetchPack (Job&, boost::weak_ptr<Peer> wPeer, 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) Ledger::pointer wantLedger, Ledger::pointer haveLedger, uint32 uUptime)
{ {
if (UptimeTimer::getInstance ().getElapsedSeconds () > (uUptime + 1)) if (UptimeTimer::getInstance ().getElapsedSeconds () > (uUptime + 1))
@@ -2162,20 +2162,20 @@ void NetworkOPs::makeFetchPack (Job&, boost::weak_ptr<Peer> wPeer,
if (!peer) if (!peer)
return; return;
ripple::TMGetObjectByHash reply; protocol::TMGetObjectByHash reply;
reply.set_query (false); reply.set_query (false);
if (request->has_seq ()) if (request->has_seq ())
reply.set_seq (request->seq ()); reply.set_seq (request->seq ());
reply.set_ledgerhash (request->ledgerhash ()); reply.set_ledgerhash (request->ledgerhash ());
reply.set_type (ripple::TMGetObjectByHash::otFETCH_PACK); reply.set_type (protocol::TMGetObjectByHash::otFETCH_PACK);
do do
{ {
uint32 lSeq = wantLedger->getLedgerSeq (); uint32 lSeq = wantLedger->getLedgerSeq ();
ripple::TMIndexedObject& newObj = *reply.add_objects (); protocol::TMIndexedObject& newObj = *reply.add_objects ();
newObj.set_hash (wantLedger->getHash ().begin (), 256 / 8); newObj.set_hash (wantLedger->getHash ().begin (), 256 / 8);
Serializer s (256); Serializer s (256);
s.add32 (HashPrefix::ledgerMaster); s.add32 (HashPrefix::ledgerMaster);
@@ -2199,7 +2199,7 @@ void NetworkOPs::makeFetchPack (Job&, boost::weak_ptr<Peer> wPeer,
while (wantLedger && (UptimeTimer::getInstance ().getElapsedSeconds () <= (uUptime + 1))); while (wantLedger && (UptimeTimer::getInstance ().getElapsedSeconds () <= (uUptime + 1)));
WriteLog (lsINFO, NetworkOPs) << "Built fetch pack with " << reply.objects ().size () << " nodes"; 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); peer->sendPacket (msg, false);
} }
catch (...) catch (...)

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

@@ -206,17 +206,17 @@ public:
Blob const& myNode, std::list< Blob >& newNodes); Blob const& myNode, std::list< Blob >& newNodes);
// ledger proposal/close functions // 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); RippleAddress nodePublic, uint256 checkLedger, bool sigGood);
SHAMapAddNode gotTXData (const boost::shared_ptr<Peer>& peer, uint256 const& hash, SHAMapAddNode gotTXData (const boost::shared_ptr<Peer>& peer, uint256 const& hash,
const std::list<SHAMapNode>& nodeIDs, const std::list< Blob >& nodeData); const std::list<SHAMapNode>& nodeIDs, const std::list< Blob >& nodeData);
bool recvValidation (SerializedValidation::ref val, const std::string& source); bool recvValidation (SerializedValidation::ref val, const std::string& source);
void takePosition (int seq, SHAMap::ref position); void takePosition (int seq, SHAMap::ref position);
SHAMap::pointer getTXMap (uint256 const& hash); 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); void mapComplete (uint256 const& hash, SHAMap::ref map);
bool stillNeedTXSet (uint256 const& hash); 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); Ledger::pointer wantLedger, Ledger::pointer haveLedger, uint32 uUptime);
bool shouldFetchPack (uint32 seq); bool shouldFetchPack (uint32 seq);
void gotFetchPack (bool progress, 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 // VFALCO TODO Rename the protobuf namespace from ripple to 'wire' or something
// //
package ripple; package protocol;
enum MessageType 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 ()); tmGL.set_ledgerhash (mHash.begin (), mHash.size ());
if (getTimeouts () != 0) if (getTimeouts () != 0)
{ {
tmGL.set_querytype (ripple::qtINDIRECT); tmGL.set_querytype (protocol::qtINDIRECT);
if (!isProgress () && !mFailed && mByHash && (getTimeouts () > LEDGER_TIMEOUT_AGGRESSIVE)) if (!isProgress () && !mFailed && mByHash && (getTimeouts () > LEDGER_TIMEOUT_AGGRESSIVE))
{ {
@@ -330,7 +330,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (!need.empty ()) if (!need.empty ())
{ {
ripple::TMGetObjectByHash tmBH; protocol::TMGetObjectByHash tmBH;
tmBH.set_query (true); tmBH.set_query (true);
tmBH.set_ledgerhash (mHash.begin (), mHash.size ()); tmBH.set_ledgerhash (mHash.begin (), mHash.size ());
bool typeSet = false; bool typeSet = false;
@@ -346,11 +346,11 @@ void InboundLedger::trigger (Peer::ref peer)
if (p.first == tmBH.type ()) 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 ()); 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); boost::recursive_mutex::scoped_lock sl (mLock);
@@ -381,7 +381,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (!mHaveBase && !mFailed) 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"); WriteLog (lsTRACE, InboundLedger) << "Sending base request to " << (peer ? "selected peer" : "all peers");
sendRequest (tmGL, peer); sendRequest (tmGL, peer);
return; return;
@@ -397,7 +397,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (mLedger->peekTransactionMap ()->getHash ().isZero ()) if (mLedger->peekTransactionMap ()->getHash ().isZero ())
{ {
// we need the root node // we need the root node
tmGL.set_itype (ripple::liTX_NODE); tmGL.set_itype (protocol::liTX_NODE);
* (tmGL.add_nodeids ()) = SHAMapNode ().getRawString (); * (tmGL.add_nodeids ()) = SHAMapNode ().getRawString ();
WriteLog (lsTRACE, InboundLedger) << "Sending TX root request to " << (peer ? "selected peer" : "all peers"); WriteLog (lsTRACE, InboundLedger) << "Sending TX root request to " << (peer ? "selected peer" : "all peers");
sendRequest (tmGL, peer); sendRequest (tmGL, peer);
@@ -430,7 +430,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (!nodeIDs.empty ()) if (!nodeIDs.empty ())
{ {
tmGL.set_itype (ripple::liTX_NODE); tmGL.set_itype (protocol::liTX_NODE);
BOOST_FOREACH (SHAMapNode & it, nodeIDs) BOOST_FOREACH (SHAMapNode & it, nodeIDs)
{ {
* (tmGL.add_nodeids ()) = it.getRawString (); * (tmGL.add_nodeids ()) = it.getRawString ();
@@ -450,7 +450,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (mLedger->peekAccountStateMap ()->getHash ().isZero ()) if (mLedger->peekAccountStateMap ()->getHash ().isZero ())
{ {
// we need the root node // we need the root node
tmGL.set_itype (ripple::liAS_NODE); tmGL.set_itype (protocol::liAS_NODE);
* (tmGL.add_nodeids ()) = SHAMapNode ().getRawString (); * (tmGL.add_nodeids ()) = SHAMapNode ().getRawString ();
WriteLog (lsTRACE, InboundLedger) << "Sending AS root request to " << (peer ? "selected peer" : "all peers"); WriteLog (lsTRACE, InboundLedger) << "Sending AS root request to " << (peer ? "selected peer" : "all peers");
sendRequest (tmGL, peer); sendRequest (tmGL, peer);
@@ -483,7 +483,7 @@ void InboundLedger::trigger (Peer::ref peer)
if (!nodeIDs.empty ()) if (!nodeIDs.empty ())
{ {
tmGL.set_itype (ripple::liAS_NODE); tmGL.set_itype (protocol::liAS_NODE);
BOOST_FOREACH (SHAMapNode & it, nodeIDs) BOOST_FOREACH (SHAMapNode & it, nodeIDs)
* (tmGL.add_nodeids ()) = it.getRawString (); * (tmGL.add_nodeids ()) = it.getRawString ();
WriteLog (lsTRACE, InboundLedger) << "Sending AS node " << nodeIDs.size () 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) if (!peer)
sendRequest (tmGL); sendRequest (tmGL);
else 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); boost::recursive_mutex::scoped_lock sl (mLock);
if (mPeers.empty ()) if (mPeers.empty ())
return; 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) 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) if (!mHaveBase)
{ {
ret.push_back (std::make_pair (ripple::TMGetObjectByHash::otLEDGER, mHash)); ret.push_back (std::make_pair (protocol::TMGetObjectByHash::otLEDGER, mHash));
return ret; return ret;
} }
@@ -814,7 +814,7 @@ std::vector<InboundLedger::neededHash_t> InboundLedger::getNeededHashes ()
AccountStateSF filter (mLedger->getLedgerSeq ()); AccountStateSF filter (mLedger->getLedgerSeq ());
std::vector<uint256> v = mLedger->getNeededAccountStateHashes (4, &filter); std::vector<uint256> v = mLedger->getNeededAccountStateHashes (4, &filter);
BOOST_FOREACH (uint256 const & h, v) 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) if (!mHaveTransactions)
@@ -822,7 +822,7 @@ std::vector<InboundLedger::neededHash_t> InboundLedger::getNeededHashes ()
TransactionStateSF filter (mLedger->getLedgerSeq ()); TransactionStateSF filter (mLedger->getLedgerSeq ());
std::vector<uint256> v = mLedger->getNeededAccountStateHashes (4, &filter); std::vector<uint256> v = mLedger->getNeededAccountStateHashes (4, &filter);
BOOST_FOREACH (uint256 const & h, v) 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; return ret;

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

@@ -79,7 +79,7 @@ public:
void noAwaitData (); void noAwaitData ();
void checkLocal (); 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 (); 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, 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 (); Peer::pointer peer = wPeer.lock ();
WriteLog (lsTRACE, InboundLedger) << "Got data (" << packet.nodes ().size () << ") for acquiring ledger: " << hash; WriteLog (lsTRACE, InboundLedger) << "Got data (" << packet.nodes ().size () << ") for acquiring ledger: " << hash;
@@ -100,7 +100,7 @@ void InboundLedgers::gotLedgerData (Job&, uint256 hash,
if (!peer) if (!peer)
return; return;
if (packet.type () == ripple::liBASE) if (packet.type () == protocol::liBASE)
{ {
if (packet.nodes_size () < 1) if (packet.nodes_size () < 1)
{ {
@@ -139,7 +139,7 @@ void InboundLedgers::gotLedgerData (Job&, uint256 hash,
return; 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<SHAMapNode> nodeIDs;
std::list< Blob > nodeData; std::list< Blob > nodeData;
@@ -153,7 +153,7 @@ void InboundLedgers::gotLedgerData (Job&, uint256 hash,
for (int i = 0; i < packet.nodes ().size (); ++i) 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 ()) if (!node.has_nodeid () || !node.has_nodedata ())
{ {
@@ -168,7 +168,7 @@ void InboundLedgers::gotLedgerData (Job&, uint256 hash,
SHAMapAddNode ret; SHAMapAddNode ret;
if (packet.type () == ripple::liTX_NODE) if (packet.type () == protocol::liTX_NODE)
ledger->takeTxNode (nodeIDs, nodeData, ret); ledger->takeTxNode (nodeIDs, nodeData, ret);
else else
ledger->takeAsNode (nodeIDs, nodeData, ret); ledger->takeAsNode (nodeIDs, nodeData, ret);

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

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

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

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

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

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

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

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

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

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