1 files changed, 74 insertions, 130 deletions

diff --git a/src/net.h b/src/net.h
index feecf96..653a015 100644
--- a/src/net.h
+++ b/src/net.h
@@ -5,7 +5,6 @@
 class CMessageHeader;
 class CAddress;
 class CInv;
-class CRequestTracker;
 class CNode;
 // Defined in main.h, which is included after this file. Only ever used here as
 // a pointer, so the forward declaration is enough.
@@ -14,7 +13,6 @@ class CBlockIndex;
 
 
 static const unsigned short DEFAULT_PORT = htons(8433);
-static const unsigned int PUBLISH_HOPS = 5;
 enum
 {
     NODE_NETWORK = (1 << 0),
@@ -91,10 +89,9 @@ static const int          BTF_HANDSHAKE_GRACE_SECS = 60;
 
 // A serialized object cannot be larger than MAX_SIZE, so no valid network
 // message needs the old 256 MB header allowance. Keep the wire cap aligned with
-// what the deserializer can accept and bound how long one peer may sit on a
-// partial payload after a complete header has arrived.
+// what the deserializer can accept. How long a peer may sit on a partial
+// payload after a complete header has arrived is BTF_MSG_WAIT_MAX_SECS, below.
 static const unsigned int MAX_PROTOCOL_MESSAGE_SIZE = MAX_SIZE;
-static const int          BTF_INCOMPLETE_MESSAGE_TIMEOUT_SECS = 2 * 60;
 
 // Ceiling on simultaneous connections.
 //
@@ -117,6 +114,42 @@ static const unsigned int MAX_CONNECTIONS = 125;
 // this long regardless of what is still buffered.
 static const int64        DISCONNECT_DRAIN_SECS    = 60;
 
+// How long a pool may go without hearing a height from ANY peer before it
+// stops issuing jobs. Long enough that ordinary peer churn and a quiet
+// handshake window do not trip it; short enough that a deaf pool cannot build
+// more than a few blocks of private fork before it is stopped. Heights
+// 3966-4085 -- 120 blocks, 5890.50 BTF -- were mined in exactly this state.
+static const int64        BTF_NO_PEER_HEIGHT_MAX_SECS = 20 * 60;
+
+// How long a peer may leave this node waiting for the rest of a message it
+// announced in a header.
+//
+// ProcessMessages rewinds the header and breaks when the body has not all
+// arrived, which is correct for a message still in flight and unbounded for
+// one that never completes: the same header is re-read, the loop breaks
+// again, and that peer is never parsed again for the life of the process.
+// Satoshi left the note -- "need a mechanism to give up waiting for overlong
+// message size error" -- and this is it.
+//
+// It never self-corrects, because any byte that arrives refreshes nLastRecv,
+// so the inactivity timeout that would otherwise drop the peer never fires.
+// The socket stays healthy, select() keeps reporting it, and the node goes
+// silently deaf one peer at a time.
+//
+// A header may legitimately outrun its body by a round trip or two; two
+// minutes is far beyond that, and well inside BTF_RECV_TIMEOUT_SECS.
+static const int64        BTF_MSG_WAIT_MAX_SECS = 2 * 60;
+
+// Largest payload a peer may announce in a message header: MAX_PROTOCOL_MESSAGE_SIZE
+// is defined further up this file. This tree reached the same cap by the same
+// reasoning as upstream #109 -- a 256 MB allowance is eight times what the
+// deserializer will accept (serialize.h throws above MAX_SIZE), so the header
+// check admitted an allocation the parser would only reject later, after
+// BTF_MSG_WAIT_MAX_SECS of a stalled peer slot -- so only the note survives.
+//
+// Both definitions were textually clean and 59 lines apart, so the replay onto
+// upstream merged them without a conflict and only the compiler objected.
+
 // Send a ping after this long with nothing to say, so a peer running the
 // inactivity check above does not mistake a quiet node for a dead one. Must
 // stay well under BTF_RECV_TIMEOUT_SECS.
@@ -157,6 +190,7 @@ extern int nBestHeight;
 // has told us anything. Median rather than maximum so one peer claiming an
 // absurd height cannot move it.
 int GetPeerMedianHeight();
+int64 GetPeerHeightAgeSecs();
 
 // Lightweight .btf churn accounting. These counters are diagnostics only: they
 // let an operator tell stale descriptors, relay pairing failures, and paired
@@ -174,8 +208,6 @@ void BtfChurnNoteHandshakeTimeout(const string& strBtfAddr, const string& strMee
 void BtfPexCollect(std::vector<std::string>& vDescOut);
 // Verify descriptors a peer sent and remember the good ones. Returns how many.
 int  BtfPexAccept(const std::vector<std::string>& vDesc);
-void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1);
-bool AnySubscribed(unsigned int nChannel);
 void ThreadBitcoinMiner(void* parg);
 // Starts MinerThreadCount() miners; returns how many came up.
 int  StartMinerThreads();
@@ -449,13 +481,19 @@ public:
 
 
 
+// MSG_REVIEW, MSG_PRODUCT and MSG_TABLE no longer have a handler, a producer
+// or a store -- the marketplace they belonged to is gone. They stay in the
+// enum, and their names stay in ppszTypeName below, because CInv serialises
+// `type` as a plain integer: dropping them would renumber nothing today but
+// would make it tempting to renumber later, and MSG_TX and MSG_BLOCK are wire
+// values shared with every other node. Reserved, never emitted, never served.
 enum
 {
     MSG_TX = 1,
     MSG_BLOCK,
-    MSG_REVIEW,
-    MSG_PRODUCT,
-    MSG_TABLE,
+    MSG_REVIEW,     // reserved, dead
+    MSG_PRODUCT,    // reserved, dead
+    MSG_TABLE,      // reserved, dead
 };
 
 static const char* ppszTypeName[] =
@@ -542,23 +580,9 @@ public:
 
 
 
-class CRequestTracker
-{
-public:
-    void (*fn)(void*, CDataStream&);
-    void* param1;
-
-    explicit CRequestTracker(void (*fnIn)(void*, CDataStream&)=NULL, void* param1In=NULL)
-    {
-        fn = fnIn;
-        param1 = param1In;
-    }
-
-    bool IsNull()
-    {
-        return fn == NULL;
-    }
-};
+// CRequestTracker and the PushRequest/"reply" round trip lived here. Nothing
+// in this tree ever called PushRequest, so the table was always empty and the
+// "reply" handler was pure inbound parser. Both removed.
 
 
 
@@ -604,9 +628,6 @@ protected:
 public:
     int64 nReleaseTime;
     int64 nDisconnectSince;
-    map<uint256, CRequestTracker> mapRequests;
-    CCriticalSection cs_mapRequests;
-
     // inventory based relay
     set<CInv> setInventoryKnown;
     set<CInv> setInventoryKnown2;
@@ -614,9 +635,6 @@ public:
     CCriticalSection cs_inventory;
     multimap<int64, CInv> mapAskFor;
 
-    // publish and subscription
-    vector<char> vfSubscribe;
-
     // Last "btfpeers" we accepted from this node, to rate-limit the exchange.
     int64 nLastPexRecv;
 
@@ -634,12 +652,17 @@ public:
     int64 nLastSend;
     int64 nLastRecv;
     int64 nLastSendEmpty;
-    int64 nIncompleteMessageStart;
-    unsigned int nIncompleteMessageSize;
-    string strIncompleteMessageCommand;
     string strBtfAddr;
     string strBtfMeeting;
 
+    // When this peer's message loop last rewound a header without having made
+    // progress, or 0 when it is not waiting, plus how much was buffered then.
+    // The pair times a STALL rather than a duration, so a large message
+    // arriving slowly is never mistaken for one that is never arriving.
+    // See ProcessMessages.
+    int64 nMsgWaitSince;
+    unsigned int nMsgWaitSize;
+
     // Height this peer announced in its version message, or -1 if it sent a
     // version message that predates the field. Knowing how far along everyone
     // else is, is the only way a node can tell "in sync" from "not hearing".
@@ -669,13 +692,14 @@ public:
         nLastSend = 0;
         nLastRecv = 0;
         nLastSendEmpty = GetTime();
-        nIncompleteMessageStart = 0;
-        nIncompleteMessageSize = 0;
-        strIncompleteMessageCommand.clear();
         strBtfAddr.clear();
         strBtfMeeting.clear();
+        // Not waiting on anything yet. Left indeterminate, the first partial
+        // message this peer sends is measured against whatever was in this
+        // memory, and ProcessMessages drops it as unreadable on first contact.
+        nMsgWaitSince = 0;
+        nMsgWaitSize = 0;
         nStartingHeight = -1;
-        vfSubscribe.assign(256, false);
 
         // Push a version message
         /// when NTP implemented, change to just nTime = GetAdjustedTime()
@@ -703,6 +727,11 @@ public:
     {
         if (hSocket != INVALID_SOCKET)
         {
+            // Route through BtfCloseSocket so the accounting sees this close.
+            // A raw closesocket() here was invisible to sockcount, which is
+            // why the leak numbers never added up, and leaving the descriptor
+            // set afterwards is how a number that now belongs to somebody else
+            // gets closed a second time. (#103)
             BtfCloseSocket(hSocket);
             hSocket = INVALID_SOCKET;
         }
@@ -949,49 +978,6 @@ public:
     }
 
 
-    void PushRequest(const char* pszCommand,
-                     void (*fn)(void*, CDataStream&), void* param1)
-    {
-        uint256 hashReply;
-        RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
-
-        CRITICAL_BLOCK(cs_mapRequests)
-            mapRequests[hashReply] = CRequestTracker(fn, param1);
-
-        PushMessage(pszCommand, hashReply);
-    }
-
-    template<typename T1>
-    void PushRequest(const char* pszCommand, const T1& a1,
-                     void (*fn)(void*, CDataStream&), void* param1)
-    {
-        uint256 hashReply;
-        RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
-
-        CRITICAL_BLOCK(cs_mapRequests)
-            mapRequests[hashReply] = CRequestTracker(fn, param1);
-
-        PushMessage(pszCommand, hashReply, a1);
-    }
-
-    template<typename T1, typename T2>
-    void PushRequest(const char* pszCommand, const T1& a1, const T2& a2,
-                     void (*fn)(void*, CDataStream&), void* param1)
-    {
-        uint256 hashReply;
-        RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
-
-        CRITICAL_BLOCK(cs_mapRequests)
-            mapRequests[hashReply] = CRequestTracker(fn, param1);
-
-        PushMessage(pszCommand, hashReply, a1, a2);
-    }
-
-
-
-    bool IsSubscribed(unsigned int nChannel);
-    void Subscribe(unsigned int nChannel, unsigned int nHops=0);
-    void CancelSubscribe(unsigned int nChannel);
     void Disconnect();
 };
 
@@ -1048,50 +1034,8 @@ inline void RelayMessage<>(const CInv& inv, const CDataStream& ss)
 
 
 
-//
-// Templates for the publish and subscription system.
-// The object being published as T& obj needs to have:
-//   a set<unsigned int> setSources member
-//   specializations of AdvertInsert and AdvertErase
-// Currently implemented for CTable and CProduct.
-//
-
-template<typename T>
-void AdvertStartPublish(CNode* pfrom, unsigned int nChannel, unsigned int nHops, T& obj)
-{
-    // Add to sources
-    obj.setSources.insert(pfrom->addr.ip);
-
-    if (!AdvertInsert(obj))
-        return;
-
-    // Relay
-    CRITICAL_BLOCK(cs_vNodes)
-        foreach(CNode* pnode, vNodes)
-            if (pnode != pfrom && (nHops < PUBLISH_HOPS || pnode->IsSubscribed(nChannel)))
-                pnode->PushMessage("publish", nChannel, nHops, obj);
-}
-
-template<typename T>
-void AdvertStopPublish(CNode* pfrom, unsigned int nChannel, unsigned int nHops, T& obj)
-{
-    uint256 hash = obj.GetHash();
-
-    CRITICAL_BLOCK(cs_vNodes)
-        foreach(CNode* pnode, vNodes)
-            if (pnode != pfrom && (nHops < PUBLISH_HOPS || pnode->IsSubscribed(nChannel)))
-                pnode->PushMessage("pub-cancel", nChannel, nHops, hash);
-
-    AdvertErase(obj);
-}
-
-template<typename T>
-void AdvertRemoveSource(CNode* pfrom, unsigned int nChannel, unsigned int nHops, T& obj)
-{
-    // Remove a source
-    obj.setSources.erase(pfrom->addr.ip);
-
-    // If no longer supported by any sources, cancel it
-    if (obj.setSources.empty())
-        AdvertStopPublish(pfrom, nChannel, nHops, obj);
-}
+// The publish/subscribe advert templates that used to close this file
+// (AdvertStartPublish / AdvertStopPublish / AdvertRemoveSource) are gone along
+// with the marketplace objects they carried. Nothing ever handled an inbound
+// "publish" or "pub-cancel", so the machinery only ever pushed; what it pushed
+// was CProduct, which no longer exists.