Expanded DHT history analysis, and ran some more tests on DHT behaviour.

- Tweaked query parameters (quicker discard, longer requery period).

The analysis suggests that in general the DHT is running okay with some minor issues.
 - BitDHT peers respond to ~50% of FIND_NODE queries. This means we drop them, 
   and so  some ONLINE friends, become UNREACHABLE friends.

This appears to be caused by too many FIND_NODE queries reaching BitDHT, and the 
peer starts dropping them. This appears to come from specific peers, which 
are not RS nodes. Proposed solution is to Track and Filter Over-Querying Peers.
(Only one query per peer every 30 seconds).

 - Should be more lenient on the exact query matches.
Allow some dropped messages.

 - Queries appear to run longer than necessary.
A better query completion criteria needs to be established.

 


git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@6614 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libbitdht/src/bitdht/bdhistory.cc

@@ -3,21 +3,35 @@
 #include "bitdht/bdhistory.h"
 #include "bitdht/bdstddht.h"
 #include "bitdht/bdmsgs.h"
+#include <set>
 
 #define MIN_RESEND_PERIOD  60
 
-void	bdMsgHistoryList::addMsg(time_t ts, uint32_t msgType, bool incoming)
+bdMsgHistoryList::bdMsgHistoryList()
+:mPeerVersion("Unknown")
+{
+	return;
+}
+
+
+
+void	bdMsgHistoryList::addMsg(time_t ts, uint32_t msgType, bool incoming, const bdNodeId *aboutId)
 {
 //	std::cerr << "bdMsgHistoryList::addMsg()";
 //	std::cerr << std::endl;
 
-	uint32_t msg = msgType | (incoming ? MSG_DIRECTION_INCOMING : MSG_DIRECTION_OUTGOING);
+	bdMsgHistoryItem msg(msgType, incoming, aboutId);
 	msgHistory.insert(std::make_pair(ts, msg));
 }
 
+void 	bdMsgHistoryList::setPeerType(time_t /* ts */, std::string version)
+{
+	mPeerVersion = version;
+}
+
 int	bdMsgHistoryList::msgCount(time_t start_ts, time_t end_ts)
 {
-	std::multimap<time_t, uint32_t>::iterator sit, eit, it;
+	std::multimap<time_t, bdMsgHistoryItem>::iterator sit, eit, it;
 	sit = msgHistory.lower_bound(start_ts);
 	eit = msgHistory.upper_bound(end_ts);
 	int count = 0;
@@ -48,11 +62,21 @@ bool	bdMsgHistoryList::msgClear(time_t before)
 	return false;
 }
 
+void	bdMsgHistoryList::msgClear()
+{
+	msgHistory.clear();
+}
+
+
+void	bdMsgHistoryList::clearHistory()
+{
+	msgClear();
+}
 
 void	bdMsgHistoryList::printHistory(std::ostream &out, int mode, time_t start_ts, time_t end_ts)
 {
 	//out << "AGE: MSGS  => incoming, <= outgoing"  << std::endl;
-	std::multimap<time_t, uint32_t>::iterator sit, eit, it;
+	std::multimap<time_t, bdMsgHistoryItem>::iterator sit, eit, it;
 	sit = msgHistory.lower_bound(start_ts);
 	eit = msgHistory.upper_bound(end_ts);
 	time_t curr_ts = 0;
@@ -86,28 +110,31 @@ void	bdMsgHistoryList::printHistory(std::ostream &out, int mode, time_t start_ts
 				out << "\tTS: " << time(NULL) - curr_ts << " ";
 			}
 	
-			if (MSG_DIRECTION_INCOMING & it->second)
-			{
-				uint32_t type = it->second-MSG_DIRECTION_INCOMING;
-				out << "( => ";
 			std::string name;
-				if (bitdht_msgtype(type, name))
+			bitdht_msgtype(it->second.msgType, name);
+
+			if (it->second.incoming)
 			{
-					out << name;
+				out << "( =I> ";
-				}
-				out << " )";
 			}
 			else
 			{
-				out << "( ";
+				out << "( <O= ";
-				uint32_t type = it->second - MSG_DIRECTION_OUTGOING;
+			}
-				std::string name;
+
-				if (bitdht_msgtype(type, name))
+			out << name << " ";
+			if ((it->second.aboutId.data[0] == 0)
+				&& (it->second.aboutId.data[3] == 0)
+				&& (it->second.aboutId.data[3] == 0)
+				&& (it->second.aboutId.data[3] == 0))
 			{
-					out << name;
+				/* don't print anything */
 			}
-				out << " <= )";
+			else
+			{
+				bdStdPrintNodeId(out, &(it->second.aboutId));
 			}
+			out << " )";
 
 		}
 			break;
@@ -126,7 +153,7 @@ bool	bdMsgHistoryList::canSend()
 {
 	std::cerr << "bdMsgHistoryList::canSend()";
 
-	std::multimap<time_t, uint32_t>::reverse_iterator rit;
+	std::multimap<time_t, bdMsgHistoryItem>::reverse_iterator rit;
 
 	rit = msgHistory.rbegin();
 	if (rit != msgHistory.rend())
@@ -159,11 +186,11 @@ bool	bdMsgHistoryList::validPeer()
 {
 	std::cerr << "bdMsgHistoryList::validPeer()";
 
-	std::multimap<time_t, uint32_t>::iterator it;
+	std::multimap<time_t, bdMsgHistoryItem>::iterator it;
 
 	for(it = msgHistory.begin(); it != msgHistory.end(); it++)
 	{
-		if (MSG_DIRECTION_INCOMING & it->second)
+		if (it->second.incoming)
 		{
 			std::cerr << " Incoming Msg... so validPeer";
 			std::cerr << std::endl;
@@ -179,11 +206,123 @@ bool	bdMsgHistoryList::validPeer()
 }
 
 
+#define MAX_PING_PER_MINUTE  	2
+#define MAX_QUERY_PER_MINUTE 	2
+
+bool bdMsgHistoryList::analysePeer()
+
+{
+	/* analyse and print out details of the peers messages */
+	bool flagged = false;
+
+	//out << "AGE: MSGS  => incoming, <= outgoing"  << std::endl;
+	std::multimap<time_t, bdMsgHistoryItem>::iterator sit, eit, it;
+	sit = msgHistory.begin();
+	eit = msgHistory.end();
+	if (sit == eit)
+	{
+		// nothing here.
+		return false;
+	}
+
+	time_t start_ts = sit->first;
+	time_t end_ts = msgHistory.rbegin()->first; // must exist.
+
+
+	// don't divide by zero.
+	if (end_ts - start_ts < 60)
+	{
+		end_ts = start_ts + 60;
+	}
+
+
+	/* what do we want to analyse? */
+
+	/* if we have sent / recved too many queries or pings */
+
+	int in_ping = 0;
+	int out_ping = 0;
+	int in_query = 0;
+	int out_query = 0;
+	int in_other = 0;
+	int out_other = 0;
+
+	for(it = sit; it != eit; it++)
+	{
+		if (it->second.incoming)
+		{
+			switch(it->second.msgType)
+			{
+				case BITDHT_MSG_TYPE_PING:
+					in_ping++;
+					break;
+				case BITDHT_MSG_TYPE_FIND_NODE:
+					in_query++;
+					break;
+				default:
+					in_other++;
+					break;
+			}
+		}
+		else
+		{
+			switch(it->second.msgType)
+			{
+				case BITDHT_MSG_TYPE_PING:
+					out_ping++;
+					break;
+				case BITDHT_MSG_TYPE_FIND_NODE:
+					out_query++;
+					break;
+				default:
+					out_other++;
+					break;
+			}
+		}
+
+	}
+
+	float in_ping_per_min = in_ping * 60.0 / (end_ts - start_ts);
+	float out_ping_per_min = out_ping * 60.0 / (end_ts - start_ts);
+	float in_query_per_min = in_query * 60.0 / (end_ts - start_ts);
+	float out_query_per_min = out_query * 60.0 / (end_ts - start_ts);
+
+	if ((in_ping_per_min > MAX_PING_PER_MINUTE) ||
+		(out_ping_per_min > MAX_PING_PER_MINUTE) ||
+		(in_query_per_min > MAX_PING_PER_MINUTE) ||
+		(out_query_per_min > MAX_PING_PER_MINUTE))
+	{
+		flagged = true;
+	}
+
+	if (flagged)
+	{
+		/* print header */
+		std::ostream &out = std::cerr;
+		out << "BdHistoryAnalysis has flagged peer: ";
+		bdStdPrintId(out, &mId);
+		out << std::endl;
+
+		out << "PeerType: " << mPeerVersion;
+		out << std::endl;
+
+		out << "Ping In Per Min  : " << in_ping_per_min << std::endl;
+		out << "Ping Out Per Min : " << out_ping_per_min << std::endl;
+		out << "Query In Per Min : " << in_query_per_min << std::endl;
+		out << "Query Out Per Min: " << out_query_per_min << std::endl;
+
+		out << "Message History: ";
+		out << std::endl;
+
+		printHistory(out, 0, 0, time(NULL));
+	}
+	return true;
+}
+
 bdHistory::bdHistory(time_t store_period)
  :mStorePeriod(store_period) { return; }
 
-
+void bdHistory::addMsg(const bdId *id, bdToken * /*transId*/, uint32_t msgType, bool incoming, const bdNodeId *aboutId)
-void bdHistory::addMsg(const bdId *id, bdToken * /*transId*/, uint32_t msgType, bool incoming)
 {
 	//std::cerr << "bdHistory::addMsg() ";
 	//bdStdPrintId(std::cerr, id);
@@ -193,10 +332,18 @@ void bdHistory::addMsg(const bdId *id, bdToken * /*transId*/, uint32_t msgType,
 
 	std::map<bdId, bdMsgHistoryList>::iterator it;
 	bdMsgHistoryList &histRef = mHistory[*id]; /* will instaniate empty */
-	histRef.addMsg(now, msgType, incoming);
+	histRef.mId = *id;
+	histRef.addMsg(now, msgType, incoming, aboutId);
 
 	/* add to mMsgTimeline */
-	mMsgTimeline.insert(std::make_pair(now, MsgRegister(id, msgType, incoming)));
+	mMsgTimeline.insert(std::make_pair(now, MsgRegister(id, msgType, incoming, aboutId)));
+}
+
+void bdHistory::setPeerType(const bdId *id, std::string version)
+{
+	std::map<bdId, bdMsgHistoryList>::iterator it;
+	bdMsgHistoryList &histRef = mHistory[*id]; /* will instaniate empty */
+	histRef.setPeerType(time(NULL), version);
 }
 
 void bdHistory::printMsgs()
@@ -216,13 +363,13 @@ void bdHistory::printMsgs()
 			/* print header */
 			out << "Msgs for ";
 			bdStdPrintId(out, &(it->first));
+			out << " v:" << it->second.mPeerVersion;
 			out << std::endl;
 
 			it->second.printHistory(out, 0, 0, time(NULL));
 		}
 	}
 
-
 	out << "Msg Timeline:";
 	time_t now = time(NULL);
 	std::multimap<time_t, MsgRegister>::iterator hit;
@@ -233,11 +380,11 @@ void bdHistory::printMsgs()
 
 		if (hit->second.incoming)
 		{
-			out << " => ";
+			out << " =I> ";
 		}
 		else
 		{
-			out << " <= ";
+			out << " <O= ";
 		}
 
 		std::string name;
@@ -264,8 +411,8 @@ void bdHistory::cleanupOldMsgs()
 		return; // no cleanup
 	}
 
-	std::list<bdId> to_cleanup;
+	std::set<bdId> to_cleanup;
-	std::list<bdId>::iterator cit;
+	std::set<bdId>::iterator cit;
 
 	time_t before = time(NULL) - mStorePeriod;
 
@@ -273,7 +420,7 @@ void bdHistory::cleanupOldMsgs()
 	while((mMsgTimeline.begin() != mMsgTimeline.end()) && (mMsgTimeline.begin()->first < before))
 	{
 		std::multimap<time_t, MsgRegister>::iterator it = mMsgTimeline.begin();
-		to_cleanup.push_back(it->second.id);
+		to_cleanup.insert(it->second.id);
 		mMsgTimeline.erase(it);
 	}
 
@@ -286,20 +433,31 @@ void bdHistory::cleanupOldMsgs()
 		{
 			if (hit->second.msgClear(before))
 			{
-				mHistory.erase(hit);
+				// don't erase actual entry (so we remember peer type).
+				//mHistory.erase(hit);
 			}
 		}
 	}
 }
 
 
+
 void bdHistory::clearHistory()
 {
-	mHistory.clear();
+	// Switched to a alternative clear, so we don't drop peers, and remember their type.
+	//mHistory.clear();
+	
+
+	std::map<bdId, bdMsgHistoryList> ::iterator it;
+	for(it = mHistory.begin(); it != mHistory.end(); it++)
+	{
+		it->second.clearHistory();
+	}
 }
 
 bool bdHistory::canSend(const bdId *id)
 {
+
 	std::map<bdId, bdMsgHistoryList> ::iterator it;
 	it = mHistory.find(*id);
 	if (it != mHistory.end())
@@ -325,4 +483,144 @@ bool bdHistory::validPeer(const bdId *id)
 	return false;
 }
 
+bool bdHistory::analysePeers()
+{
+	std::map<bdId, bdMsgHistoryList> ::iterator it;
+	for(it = mHistory.begin(); it != mHistory.end(); it++)
+	{
+		it->second.analysePeer();
+	}
+	return true;
+}
+
+
+
+/* Temp data class. */
+class TypeStats
+{
+	public:
+
+	TypeStats() :nodes(0) { return; }
+
+	std::map<uint32_t, uint32_t> incoming, outgoing;
+	int nodes;
+
+
+void	printStats(std::ostream &out, const TypeStats *refStats)
+{
+	std::map<uint32_t, uint32_t>::iterator it;
+	std::map<uint32_t, uint32_t>::const_iterator rit;
+
+	out << "  Nodes: " << nodes;
+	if (refStats)
+	{
+		out << " (" << 100.0 * nodes / (float) refStats->nodes << " %)";
+	}
+	out << std::endl;
+
+	out << "  Incoming Msgs";
+	out << std::endl;
+	for(it = incoming.begin(); it != incoming.end(); it++)
+	{
+		uint32_t count = 0;
+		if (refStats)
+		{			
+			rit = refStats->incoming.find(it->first);
+			if (rit != refStats->incoming.end())
+			{
+				count = rit->second;
+			}
+		}
+		printStatsLine(out, it->first, it->second, count);
+	}
+
+	out << "  Outgoing Msgs";
+	out << std::endl;
+	for(it = outgoing.begin(); it != outgoing.end(); it++)
+	{
+		uint32_t count = 0;
+		if (refStats)
+		{			
+			rit = refStats->outgoing.find(it->first);
+			if (rit != refStats->outgoing.end())
+			{
+				count = rit->second;
+			}
+		}
+		printStatsLine(out, it->first, it->second, count);
+	}
+}
+
+
+
+void   printStatsLine(std::ostream &out, uint32_t msgType, uint32_t count, uint32_t global)
+{
+	std::string name;
+	bitdht_msgtype(msgType, name);
+	out << "\t" << name << " " << count;
+	if (global != 0)
+	{
+		out << " (" << 100.0 * count / (float) global << " %)";
+	}
+	out << std::endl;
+}
+
+}; /* end of TypeStats */
+
+bool bdHistory::peerTypeAnalysis()
+{
+
+	std::map<std::string, TypeStats> mTypeStats;
+	TypeStats globalStats;
+
+	std::map<bdId, bdMsgHistoryList> ::iterator it;
+	for(it = mHistory.begin(); it != mHistory.end(); it++)
+	{
+		if (it->second.msgHistory.empty())
+		{
+			continue;
+		}
+
+		std::string version = it->second.mPeerVersion;
+		// group be first two bytes.
+		version = it->second.mPeerVersion.substr(0,2);
+		TypeStats &stats = mTypeStats[version];
+
+		stats.nodes++;
+		globalStats.nodes++;
+
+		std::multimap<time_t, bdMsgHistoryItem>::iterator lit;
+		for (lit = it->second.msgHistory.begin(); lit != it->second.msgHistory.end(); lit++)
+		{
+			if (lit->second.incoming)
+			{
+				stats.incoming[lit->second.msgType]++;
+				globalStats.incoming[lit->second.msgType]++;
+			}
+			else
+			{
+				stats.outgoing[lit->second.msgType]++;
+				globalStats.outgoing[lit->second.msgType]++;
+			}
+		}
+	}
+
+
+	std::map<std::string, TypeStats>::iterator tit;
+	for(tit = mTypeStats.begin(); tit != mTypeStats.end(); tit++)
+	{
+		std::cerr << "Stats for Peer Type: " << tit->first;
+		std::cerr << std::endl;
+		tit->second.printStats(std::cerr, &globalStats);	
+	}
+
+	std::cerr << "Global Stats: ";
+	std::cerr << std::endl;
+
+	globalStats.printStats(std::cerr, NULL);
+	return true;
+
+}
+
+
 

libbitdht/src/bitdht/bdhistory.h

@@ -3,6 +3,7 @@
 
 #include "bitdht/bdpeer.h"
 #include "bitdht/bdobj.h"
+#include "bitdht/bdstddht.h"
 #include <map>
 
 #define MSG_TYPE_DIRECTION_MASK	0x000f0000
@@ -16,28 +17,78 @@ class MsgRegister
 {
         public:
         MsgRegister() { return; }
-	MsgRegister(const bdId *inId, uint32_t inMsgType, bool inIncoming)
+        MsgRegister(const bdId *inId, uint32_t inMsgType, bool inIncoming, const bdNodeId *inAboutId)
-	  :id(*inId), msgType(inMsgType), incoming(inIncoming) { return; }
+          :id(*inId), msgType(inMsgType), incoming(inIncoming) 
+	{ 
+		if (inAboutId)
+		{
+			aboutId = *inAboutId;
+		}
+		else
+		{
+			bdStdZeroNodeId(&aboutId);
+		}
+
+		return; 
+	}
 
         bdId id;
         uint32_t msgType;
         bool incoming;
+	bdNodeId aboutId; // filled in for queries.
 };
 
 
+class bdMsgHistoryItem
+{
+	public:
+	bdMsgHistoryItem() 
+          :msgType(0), incoming(false) 
+	{
+		bdStdZeroNodeId(&aboutId);
+		return;
+	}
+
+        bdMsgHistoryItem(uint32_t inMsgType, bool inIncoming, const bdNodeId *inAboutId)
+          :msgType(inMsgType), incoming(inIncoming) 
+	{ 
+		if (inAboutId)
+		{
+			aboutId = *inAboutId;
+		}
+		else
+		{
+			bdStdZeroNodeId(&aboutId);
+		}
+
+		return; 
+	}
+
+	uint32_t msgType;
+	bool incoming;
+	bdNodeId aboutId; // filled in for queries.
+};
+
 
 class bdMsgHistoryList
 {
 	public:
-void	addMsg(time_t ts, uint32_t msgType, bool incoming);
+	bdMsgHistoryList();
+void	addMsg(time_t ts, uint32_t msgType, bool incoming, const bdNodeId *aboutId);
+void 	setPeerType(time_t ts, std::string version);
 int	msgCount(time_t start_ts, time_t end_ts);
 bool    msgClear(time_t before); // 0 => clear all.
+void	msgClear();
 void	printHistory(std::ostream &out, int mode, time_t start_ts, time_t end_ts);
+bool    analysePeer();
+void    clearHistory();
 
 bool    canSend();
 bool    validPeer();
 
-	std::multimap<time_t, uint32_t> msgHistory;
+	std::multimap<time_t, bdMsgHistoryItem> msgHistory;
+	std::string mPeerVersion;
+	bdId mId;
 };
 
 
@@ -47,11 +98,14 @@ class bdHistory
 	public:
 	bdHistory(time_t store_period);
 
-void	addMsg(const bdId *id, bdToken *transId, uint32_t msgType, bool incoming);
+void	addMsg(const bdId *id, bdToken *transId, uint32_t msgType, bool incoming, const bdNodeId *aboutId);
+void 	setPeerType(const bdId *id, std::string version);
 void	printMsgs();
 
 void    cleanupOldMsgs();
 void    clearHistory();
+bool    analysePeers();
+bool 	peerTypeAnalysis();
 
 bool    canSend(const bdId *id);
 bool    validPeer(const bdId *id);
@@ -62,6 +116,7 @@ bool    validPeer(const bdId *id);
 	std::multimap<time_t, MsgRegister> mMsgTimeline;
 
 	int mStorePeriod;
+
 };
 
 

libbitdht/src/bitdht/bdnode.cc

@@ -45,7 +45,7 @@
 #define BITDHT_QUERY_START_PEERS    10
 #define BITDHT_QUERY_NEIGHBOUR_PEERS    8
 
-#define BITDHT_MAX_REMOTE_QUERY_AGE	10
+#define BITDHT_MAX_REMOTE_QUERY_AGE	3 //  3 seconds, keep it fresh.
 #define MAX_REMOTE_PROCESS_PER_CYCLE	5
 
 /****
@@ -270,6 +270,8 @@ void bdNode::printState()
 #ifdef USE_HISTORY
 	mHistory.cleanupOldMsgs();
 	mHistory.printMsgs();
+	mHistory.analysePeers();
+	mHistory.peerTypeAnalysis();
 #endif
 
 	mAccount.printStats(std::cerr);
@@ -809,7 +811,7 @@ void bdNode::msgout_ping(bdId *id, bdToken *transId)
 	//registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_PING);
 
 	bdId dupId(*id);
-	registerOutgoingMsg(&dupId, transId, BITDHT_MSG_TYPE_PING);
+	registerOutgoingMsg(&dupId, transId, BITDHT_MSG_TYPE_PING, NULL);
 	
         /* create string */
         char msg[10240];
@@ -834,7 +836,7 @@ void bdNode::msgout_pong(bdId *id, bdToken *transId)
 	std::cerr << std::endl;
 #endif
 
-	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_PONG);
+	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_PONG, NULL);
 
 	/* generate message, send to udp */
 	bdToken vid;
@@ -870,7 +872,7 @@ void bdNode::msgout_find_node(bdId *id, bdToken *transId, bdNodeId *query)
 	std::cerr << std::endl;
 #endif
 
-	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_FIND_NODE);
+	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_FIND_NODE, query);
 	
 
 
@@ -890,7 +892,7 @@ void bdNode::msgout_reply_find_node(bdId *id, bdToken *transId, std::list<bdId>
         char msg[10240];
         int avail = 10240;
 
-	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_REPLY_NODE);
+	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_REPLY_NODE, NULL);
 	
 	mAccount.incCounter(BDACCOUNT_MSG_REPLYFINDNODE, true);
 
@@ -934,7 +936,7 @@ void bdNode::msgout_get_hash(bdId *id, bdToken *transId, bdNodeId *info_hash)
         char msg[10240];
         int avail = 10240;
 
-	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_GET_HASH);
+	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_GET_HASH, info_hash);
 
 	
         int blen = bitdht_get_peers_msg(transId, &(mOwnId), info_hash, msg, avail-1);
@@ -968,7 +970,7 @@ void bdNode::msgout_reply_hash(bdId *id, bdToken *transId, bdToken *token, std::
         char msg[10240];
         int avail = 10240;
 
-	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_REPLY_HASH);
+	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_REPLY_HASH, NULL);
 
         int blen = bitdht_peers_reply_hash_msg(transId, &(mOwnId), token, values, msg, avail-1);
 
@@ -1001,7 +1003,7 @@ void bdNode::msgout_reply_nearest(bdId *id, bdToken *transId, bdToken *token, st
         char msg[10240];
         int avail = 10240;
 	
-	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_REPLY_NEAR);
+	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_REPLY_NEAR, NULL);
 	
 
 	
@@ -1031,7 +1033,7 @@ void bdNode::msgout_post_hash(bdId *id, bdToken *transId, bdNodeId *info_hash, u
         char msg[10240];
         int avail = 10240;
 	
-	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_POST_HASH);
+	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_POST_HASH, info_hash);
 	
 	
         int blen = bitdht_announce_peers_msg(transId,&(mOwnId),info_hash,port,token,msg,avail-1);
@@ -1056,7 +1058,7 @@ void bdNode::msgout_reply_post(bdId *id, bdToken *transId)
 	char msg[10240];
 	int avail = 10240;
 
-	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_REPLY_POST);
+	registerOutgoingMsg(id, transId, BITDHT_MSG_TYPE_REPLY_POST, NULL);
 
 	int blen = bitdht_reply_announce_msg(transId, &(mOwnId), msg, avail-1);
 
@@ -1481,7 +1483,15 @@ void    bdNode::recvPkt(char *msg, int len, struct sockaddr_in addr)
 	/* Construct Source Id */
 	bdId srcId(id, addr);
 
-	registerIncomingMsg(&srcId, &transId, beType);
+	if (be_target)
+	{	
+		registerIncomingMsg(&srcId, &transId, beType, &target_info_hash);
+	}
+	else
+	{
+		registerIncomingMsg(&srcId, &transId, beType, NULL);
+	}
+
 	switch(beType)
 	{
 		case BITDHT_MSG_TYPE_PING:  /* a: id, transId */
@@ -1681,6 +1691,22 @@ void bdNode::msgin_pong(bdId *id, bdToken *transId, bdToken *versionId)
 		std::cerr << std::endl;
 #endif
 
+#ifdef USE_HISTORY
+		std::string version;
+		for(int i = 0; i < versionId->len; i++)
+		{
+			if (isalnum(versionId->data[i]))
+			{
+				version += versionId->data[i];
+			}
+			else
+			{
+				version += 'X';
+			}
+		}
+		mHistory.setPeerType(id, version);
+#endif
+	
 		/* check two bytes */
 		if ((versionId->len >= 2) && (mDhtVersion.size() >= 2) &&
 			(versionId->data[0] == mDhtVersion[0]) && (versionId->data[1] == mDhtVersion[1]))
@@ -2014,7 +2040,7 @@ void bdNode::msgout_connect_genmsg(bdId *id, bdToken *transId, int msgtype, bdId
 			break;
 	}
 			
-	registerOutgoingMsg(id, transId, msgtype);
+	registerOutgoingMsg(id, transId, msgtype, NULL);
 	
         /* create string */
         char msg[10240];
@@ -2163,7 +2189,7 @@ int bdNode::queueQuery(bdId *id, bdNodeId *query, bdToken *transId, uint32_t que
 
 /*************** Register Transaction Ids *************/
 
-void bdNode::registerOutgoingMsg(bdId *id, bdToken *transId, uint32_t msgType)
+void bdNode::registerOutgoingMsg(bdId *id, bdToken *transId, uint32_t msgType, bdNodeId *aboutId)
 {
 	
 #ifdef DEBUG_MSG_CHECKS
@@ -2177,9 +2203,41 @@ void bdNode::registerOutgoingMsg(bdId *id, bdToken *transId, uint32_t msgType)
 #endif
 	
 #ifdef USE_HISTORY
-	mHistory.addMsg(id, transId, msgType, false);
+
+	// splitting up - to see if we can isolate the crash causes.
+	switch(msgType)
+	{
+		// disabled types (which appear to crash it!)
+		case BITDHT_MSG_TYPE_PING:
+			if (!id)
+			{
+				return;
+			}
+			if ((id->id.data[0] == 0)
+			  && (id->id.data[1] == 0)
+			  && (id->id.data[2] == 0)
+			  && (id->id.data[3] == 0))
+			{
+				return;
+			}
+			break;
+		case BITDHT_MSG_TYPE_UNKNOWN:
+		case BITDHT_MSG_TYPE_PONG:
+		case BITDHT_MSG_TYPE_FIND_NODE:
+		case BITDHT_MSG_TYPE_REPLY_NODE:
+		case BITDHT_MSG_TYPE_GET_HASH:
+		case BITDHT_MSG_TYPE_REPLY_HASH:
+		case BITDHT_MSG_TYPE_REPLY_NEAR:
+		case BITDHT_MSG_TYPE_POST_HASH:
+		case BITDHT_MSG_TYPE_REPLY_POST:
+			break;
+	}
+
+	// This line appears to cause crashes on OSX.
+	mHistory.addMsg(id, transId, msgType, false, aboutId);
 #else
 	(void) transId;
+	(void) aboutId;
 #endif
 	
 	
@@ -2201,7 +2259,7 @@ void bdNode::registerOutgoingMsg(bdId *id, bdToken *transId, uint32_t msgType)
 
 
 
-uint32_t bdNode::registerIncomingMsg(bdId *id, bdToken *transId, uint32_t msgType)
+uint32_t bdNode::registerIncomingMsg(bdId *id, bdToken *transId, uint32_t msgType, bdNodeId *aboutId)
 {
 	
 #ifdef DEBUG_MSG_CHECKS
@@ -2215,9 +2273,10 @@ uint32_t bdNode::registerIncomingMsg(bdId *id, bdToken *transId, uint32_t msgTyp
 #endif
 	
 #ifdef USE_HISTORY
-	mHistory.addMsg(id, transId, msgType, true);
+	mHistory.addMsg(id, transId, msgType, true, aboutId);
 #else
 	(void) transId;
+	(void) aboutId;
 #endif
 	
 	return 0;

libbitdht/src/bitdht/bdnode.h

@@ -218,8 +218,8 @@ void	recvPkt(char *msg, int len, struct sockaddr_in addr);
 
 	/* transId handling */
 	void genNewTransId(bdToken *token);
-	void registerOutgoingMsg(bdId *id, bdToken *transId, uint32_t msgType);
+	void registerOutgoingMsg(bdId *id, bdToken *transId, uint32_t msgType, bdNodeId *aboutId);
-	uint32_t registerIncomingMsg(bdId *id, bdToken *transId, uint32_t msgType);
+	uint32_t registerIncomingMsg(bdId *id, bdToken *transId, uint32_t msgType, bdNodeId *aboutId);
 
 	void cleanupTransIdRegister();
 

libbitdht/src/bitdht/bdquery.cc

@@ -37,8 +37,8 @@
 **/
 
 #define EXPECTED_REPLY 10 // Speed up queries
-#define QUERY_IDLE_RETRY_PEER_PERIOD 300 // 5min =  (mFns->bdNumQueryNodes() * 30)
+#define QUERY_IDLE_RETRY_PEER_PERIOD 600 // 10min =  (mFns->bdNumQueryNodes() * 60)
-#define MAX_QUERY_IDLE_PERIOD 	     900 // 15min.
+#define MAX_QUERY_IDLE_PERIOD 	     1200 // 20min.
 
 
 /************************************************************
@@ -980,6 +980,7 @@ int     bdQuery::printQuery()
 		fprintf(stderr, "Id:  ");
 		mFns->bdPrintId(std::cerr, &(it->second.mPeerId));
 		fprintf(stderr, "  Bucket: %d ", mFns->bdBucketDistance(&(it->first)));
+		fprintf(stderr," Flags: %x", it->second.mPeerFlags);
 		fprintf(stderr," Found: %ld ago", ts-it->second.mFoundTime);
 		fprintf(stderr," LastSent: %ld ago", ts-it->second.mLastSendTime);
 		fprintf(stderr," LastRecv: %ld ago", ts-it->second.mLastRecvTime);
@@ -992,35 +993,12 @@ int     bdQuery::printQuery()
 		fprintf(stderr, "Id:  ");
 		mFns->bdPrintId(std::cerr, &(it->second.mPeerId));
 		fprintf(stderr, "  Bucket: %d ", mFns->bdBucketDistance(&(it->first)));
+		fprintf(stderr," Flags: %x", it->second.mPeerFlags);
 		fprintf(stderr," Found: %ld ago", ts-it->second.mFoundTime);
 		fprintf(stderr," LastSent: %ld ago", ts-it->second.mLastSendTime);
 		fprintf(stderr," LastRecv: %ld ago", ts-it->second.mLastRecvTime);
 		fprintf(stderr, "\n");
 	}
-
-	std::list<bdPeer>::iterator lit;
-	fprintf(stderr, "\nProxies Flagged:\n");
-	for(lit = mProxiesFlagged.begin(); lit != mProxiesFlagged.end(); lit++)
-	{
-		fprintf(stderr, "ProxyId:  ");
-		mFns->bdPrintId(std::cerr, &(lit->mPeerId));
-		fprintf(stderr," Found: %ld ago", ts-lit->mFoundTime);
-		fprintf(stderr," LastSent: %ld ago", ts-lit->mLastSendTime);
-		fprintf(stderr," LastRecv: %ld ago", ts-lit->mLastRecvTime);
-		fprintf(stderr, "\n");
-	}
-
-	fprintf(stderr, "\nProxies Unknown:\n");
-	for(lit = mProxiesUnknown.begin(); lit != mProxiesUnknown.end(); lit++)
-	{
-		fprintf(stderr, "ProxyId:  ");
-		mFns->bdPrintId(std::cerr, &(lit->mPeerId));
-		fprintf(stderr," Found: %ld ago", ts-lit->mFoundTime);
-		fprintf(stderr," LastSent: %ld ago", ts-lit->mLastSendTime);
-		fprintf(stderr," LastRecv: %ld ago", ts-lit->mLastRecvTime);
-		fprintf(stderr, "\n");
-	}
-	
 #else
 	// shortened version.
 	fprintf(stderr, "Closest Available Peer: ");
@@ -1049,6 +1027,7 @@ int     bdQuery::printQuery()
 	}
 	fprintf(stderr, "\n");
 
+#endif
 	std::list<bdPeer>::iterator lit;
 	fprintf(stderr, "Flagged Proxies:\n");
 	for(lit = mProxiesFlagged.begin(); lit != mProxiesFlagged.end(); lit++)
@@ -1073,7 +1052,6 @@ int     bdQuery::printQuery()
 		fprintf(stderr," LastRecv: %ld ago", ts-lit->mLastRecvTime);
 		fprintf(stderr, "\n");
 	}
-#endif
 
 	return 1;
 }

libbitdht/src/bitdht/bdstore.cc

@@ -80,7 +80,7 @@ int bdStore::reloadFromStore()
 			{
 				addr.sin_port = htons(port);
 				bdPeer peer;
-				//bdZeroNodeId(&(peer.mPeerId.id));
+				bdZeroNodeId(&(peer.mPeerId.id));
 				peer.mPeerId.addr = addr;
 				peer.mLastSendTime = 0;
 				peer.mLastRecvTime = 0;