Integrated NetStateBox and Activated Stunners.

* Added tick() and setRefreshPeriod() to pqiAddrAssist
 * Fixed up NETSTATE #defines, all refer to retroshare/rsconfig.h
 * added #define => string translations for NETSTATEs
 * Added NetStateBox as an independent Network State determination (has no effect on existing code).
 * added slowTick() to p3NetMgr.
 * connected p3NetMgr::getNet... to NetStateBox.
 * piped network state into NetStateBox.
 * added p3NetMgr check for changes in NatType. (to update Stun Rate / Attach Mode (TODO))
 * added NetStateBox.reset()
 * tweaked lots of debugging.
 * added Default Stun Period (pass -1 to setRefreshPeriod()) 



git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-netupgrade@4435 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libretroshare/src/dht/stunaddrassist.h

@@ -44,6 +44,16 @@ virtual bool    getExternalAddr(struct sockaddr_in &remote, uint8_t &stable)
                 return mStunner->externalAddr(remote, stable);
         }
 
+virtual int     tick()
+	{
+                return mStunner->tick();
+        }
+
+virtual void    setRefreshPeriod(int32_t period)
+	{
+		return mStunner->setTargetStunPeriod(period);
+	}
+
 	private:
 
 	UdpStunner *mStunner;

libretroshare/src/pqi/p3linkmgr.cc

@@ -56,9 +56,6 @@ const int p3connectzone = 3431;
  * #define LINKMGR_DEBUG_ACTIONS  1
  ***/
 
-#define LINKMGR_DEBUG_CONNFAIL 		1
-#define LINKMGR_DEBUG_ACTIONS  		1
-
 
 /****
  * #define P3CONNMGR_NO_TCP_CONNECTIONS 1

libretroshare/src/pqi/p3netmgr.cc

@@ -41,6 +41,7 @@
 #include "serialiser/rsconfigitems.h"
 #include "pqi/pqinotify.h"
 #include "retroshare/rsiface.h"
+#include "retroshare/rsconfig.h"
 
 #include <sstream>
 
@@ -71,8 +72,10 @@ const uint32_t MIN_TIME_BETWEEN_NET_RESET = 		5;
  * #define NETMGR_DEBUG 1
  * #define NETMGR_DEBUG_RESET 1
  * #define NETMGR_DEBUG_TICK 1
+ * #define NETMGR_DEBUG_STATEBOX 1
  ***/
 
+#define NETMGR_DEBUG_STATEBOX 1
 
 pqiNetStatus::pqiNetStatus()
 	:mLocalAddrOk(false), mExtAddrOk(false), mExtAddrStableOk(false), 
@@ -125,6 +128,9 @@ p3NetMgr::p3NetMgr()
 		mNetFlags = pqiNetStatus();
 		mOldNetFlags = pqiNetStatus();
 
+		mLastSlowTickTime = 0;
+		mOldNatType = RSNET_NATTYPE_UNKNOWN;
+		mOldNatHole = RSNET_NATHOLE_UNKNOWN;
 	}
 	
 #ifdef NETMGR_DEBUG
@@ -154,32 +160,6 @@ void p3NetMgr::setAddrAssist(pqiAddrAssist *dhtStun, pqiAddrAssist *proxyStun)
 }
 
 
-uint32_t p3NetMgr::getNetStateMode()
-{
-	return 0;
-}
-
-uint32_t p3NetMgr::getNetworkMode()
-{
-	return 0;
-}
-
-uint32_t p3NetMgr::getNatTypeMode()
-{
-	return 0;
-}
-
-uint32_t p3NetMgr::getNatHoleMode()
-{
-	return 0;
-}
-
-uint32_t p3NetMgr::getConnectModes()
-{
-	return 0;
-}
-
-
 
 /***** Framework / initial implementation for a connection manager.
  *
@@ -304,6 +284,8 @@ void p3NetMgr::netReset()
 		netStatusReset_locked();
 	}
 
+	updateNetStateBox_reset();
+
 #ifdef NETMGR_DEBUG_RESET
 	std::cerr << "p3NetMgr::netReset() done" << std::endl;
 #endif
@@ -414,9 +396,41 @@ void p3NetMgr::netStartup()
 
 
 void p3NetMgr::tick()
+{
+	time_t now = time(NULL);
+	bool doSlowTick = false;
+	{
+		RsStackMutex stack(mNetMtx);   /************** LOCK MUTEX ***************/
+		if (now > mLastSlowTickTime)
+		{
+			mLastSlowTickTime = now;
+			doSlowTick = true;
+		}
+	}
+
+	if (doSlowTick)
+	{
+		slowTick();
+	}
+}
+
+
+void p3NetMgr::slowTick()
 {
 	netTick();
 	netAssistConnectTick();
+	updateNetStateBox_temporal();
+
+	if (mDhtStunner)
+	{
+		mDhtStunner->tick();
+	}
+
+	if (mProxyStunner)
+	{
+		mProxyStunner->tick();
+	}
+
 }
 
 #define STARTUP_DELAY 5
@@ -640,6 +654,8 @@ void p3NetMgr::netExtCheck()
 #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
 	std::cerr << "p3NetMgr::netExtCheck()" << std::endl;
 #endif
+	bool netSetupDone = false;
+
 	{
 		RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
 		bool isStable = false;
@@ -730,10 +746,14 @@ void p3NetMgr::netExtCheck()
 			mExtAddr = mNetFlags.mExtAddr;
 
 			mNetStatus = RS_NET_DONE;
+			netSetupDone = true;
+
 #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
 			std::cerr << "p3NetMgr::netExtCheck() Ext Ok: RS_NET_DONE" << std::endl;
 #endif
 
+
+
 			if (!mNetFlags.mExtAddrStableOk)
 			{
 #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
@@ -770,6 +790,7 @@ void p3NetMgr::netExtCheck()
 				}
 
 			}
+
 		}
 
 		if (mNetFlags.mExtAddrOk)
@@ -795,7 +816,17 @@ void p3NetMgr::netExtCheck()
 			std::cerr << "p3NetMgr::netExtCheck() Ext Unstable - Unreachable Check" << std::endl;
 #endif
 		}
+
+
+
 	}
+
+	if (netSetupDone)
+	{
+		/* Setup NetStateBox with this info */
+		updateNetStateBox_startup();
+	}
+
 }
 
 /**********************************************************************************************
@@ -1377,3 +1408,312 @@ void p3NetMgr::setIPServersEnabled(bool b)
 #endif
 
 }
+
+
+
+/**********************************************************************************************
+ ************************************** NetStateBox  ******************************************
+ **********************************************************************************************/
+
+uint32_t p3NetMgr::getNetStateMode()
+{
+	RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+	return mNetStateBox.getNetStateMode();
+}
+
+uint32_t p3NetMgr::getNetworkMode()
+{
+	RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+	return mNetStateBox.getNetworkMode();
+}
+
+uint32_t p3NetMgr::getNatTypeMode()
+{
+	RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+	return mNetStateBox.getNatTypeMode();
+}
+
+uint32_t p3NetMgr::getNatHoleMode()
+{
+	RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+	return mNetStateBox.getNatHoleMode();
+}
+
+uint32_t p3NetMgr::getConnectModes()
+{
+	RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+	return mNetStateBox.getConnectModes();
+}
+
+
+/* These are the regular updates from Dht / Stunners */
+void p3NetMgr::updateNetStateBox_temporal()
+{
+#ifdef	NETMGR_DEBUG_STATEBOX
+	std::cerr << "p3NetMgr::updateNetStateBox_temporal() ";
+	std::cerr << std::endl;
+#endif
+
+	uint8_t isstable = 0;
+	struct sockaddr_in tmpaddr;
+	sockaddr_clear(&tmpaddr);
+
+	if (mDhtStunner)
+	{
+
+        	/* input network bits */
+       		if (mDhtStunner->getExternalAddr(tmpaddr, isstable))
+		{
+			RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+			mNetStateBox.setAddressStunDht(&tmpaddr, isstable);
+			
+#ifdef	NETMGR_DEBUG_STATEBOX
+			std::cerr << "p3NetMgr::updateNetStateBox_temporal() DhtStunner: ";
+			std::cerr << rs_inet_ntoa(tmpaddr.sin_addr) << ":" << htons(tmpaddr.sin_port);
+			std::cerr << " Stable: " << (uint32_t) isstable;
+			std::cerr << std::endl;
+#endif
+			
+		}
+	}
+
+	if (mProxyStunner)
+	{
+
+        	/* input network bits */
+       		if (mProxyStunner->getExternalAddr(tmpaddr, isstable))
+		{
+			RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+			mNetStateBox.setAddressStunProxy(&tmpaddr, isstable);
+
+#ifdef	NETMGR_DEBUG_STATEBOX
+			std::cerr << "p3NetMgr::updateNetStateBox_temporal() ProxyStunner: ";
+			std::cerr << rs_inet_ntoa(tmpaddr.sin_addr) << ":" << htons(tmpaddr.sin_port);
+			std::cerr << " Stable: " << (uint32_t) isstable;
+			std::cerr << std::endl;
+#endif
+		
+		}
+	}
+
+
+	{
+		bool dhtOn = netAssistConnectEnabled();
+		bool dhtActive = netAssistConnectActive();
+
+		RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+		mNetStateBox.setDhtState(dhtOn, dhtActive);
+	}
+
+
+	/* now we check if a WebIP address is required? */
+
+
+	{
+		RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+
+		uint32_t netstate = mNetStateBox.getNetStateMode();
+		uint32_t netMode = mNetStateBox.getNetworkMode();
+		uint32_t natType = mNetStateBox.getNatTypeMode();
+		uint32_t natHole = mNetStateBox.getNatHoleMode();
+		uint32_t connect = mNetStateBox.getConnectModes();
+
+		std::string netstatestr = NetStateNetStateString(netstate);
+		std::string connectstr = NetStateConnectModesString(connect);
+		std::string natholestr = NetStateNatHoleString(natHole);
+		std::string nattypestr = NetStateNatTypeString(natType);
+		std::string netmodestr = NetStateNetworkModeString(netMode);
+
+#ifdef	NETMGR_DEBUG_STATEBOX
+		std::cerr << "p3NetMgr::updateNetStateBox_temporal() NetStateBox Thinking";
+		std::cerr << std::endl;
+		std::cerr << "\tNetState: " << netstatestr;
+		std::cerr << std::endl;
+		std::cerr << "\tConnectModes: " << netstatestr;
+		std::cerr << std::endl;
+		std::cerr << "\tNetworkMode: " << netmodestr;
+		std::cerr << std::endl;
+		std::cerr << "\tNatHole: " << natholestr;
+		std::cerr << std::endl;
+		std::cerr << "\tNatType: " << nattypestr;
+		std::cerr << std::endl;
+#endif
+
+	}
+	
+	
+	updateNatSetting();
+
+}
+
+#define NET_STUNNER_PERIOD_FAST		(300)	// default of Stunner.
+#define NET_STUNNER_PERIOD_SLOW		(300) 	// 5 minutes.
+
+void p3NetMgr::updateNatSetting()
+{
+	bool updateRefreshRate = false;
+	uint32_t natType = RSNET_NATTYPE_UNKNOWN;
+	uint32_t natHole = RSNET_NATHOLE_UNKNOWN;
+	{
+		RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+
+		natType = mNetStateBox.getNatTypeMode();
+		natHole = mNetStateBox.getNatHoleMode();
+		if ((natType != mOldNatType) || (natHole != mOldNatHole))
+		{
+			mOldNatType = natType;
+			mOldNatHole = natHole;
+			updateRefreshRate = true;
+			
+#ifdef	NETMGR_DEBUG_STATEBOX
+			std::cerr << "p3NetMgr::updateNetStateBox_temporal() NatType Change!";
+			std::cerr << "\tNatType: " << NetStateNatTypeString(natType);
+			std::cerr << "\tNatHole: " << NetStateNatHoleString(natHole);
+
+			std::cerr << std::endl;
+#endif
+			
+			
+		}
+	}
+
+	
+	// MUST also use this chance to set ATTACH flag for DHT.
+	if (updateRefreshRate)
+	{
+#ifdef	NETMGR_DEBUG_STATEBOX
+		std::cerr << "p3NetMgr::updateNetStateBox_temporal() Updating Refresh Rate, based on changed NatType";
+		std::cerr << std::endl;
+#endif
+		
+		
+		switch(natType)
+		{
+			case RSNET_NATTYPE_RESTRICTED_CONE: 
+			{
+				if ((natHole == RSNET_NATHOLE_NONE) || (natHole == RSNET_NATHOLE_UNKNOWN))
+				{
+					mProxyStunner->setRefreshPeriod(NET_STUNNER_PERIOD_FAST);
+				}
+				else 
+				{
+					mProxyStunner->setRefreshPeriod(NET_STUNNER_PERIOD_SLOW);
+				}
+				break;
+			}
+			case RSNET_NATTYPE_NONE:
+			case RSNET_NATTYPE_UNKNOWN:
+			case RSNET_NATTYPE_SYMMETRIC:
+			case RSNET_NATTYPE_FULL_CONE:
+			case RSNET_NATTYPE_OTHER:
+
+				mProxyStunner->setRefreshPeriod(NET_STUNNER_PERIOD_SLOW);
+				break;
+		}
+	}
+}
+
+
+
+void p3NetMgr::updateNetStateBox_startup()
+{
+#ifdef	NETMGR_DEBUG_STATEBOX
+	std::cerr << "p3NetMgr::updateNetStateBox_startup() ";
+	std::cerr << std::endl;
+#endif
+	{
+		RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+
+		/* fill in the data */
+		struct sockaddr_in tmpip;
+	
+		/* net Assist */
+		if (netAssistExtAddress(tmpip))
+		{
+
+#ifdef	NETMGR_DEBUG_STATEBOX
+			std::cerr << "p3NetMgr::updateNetStateBox_startup() ";
+			std::cerr << "Ext supplied from netAssistExternalAddress()";
+			std::cerr << std::endl;
+#endif
+
+			if (isValidNet(&(tmpip.sin_addr)))
+			{
+#ifdef	NETMGR_DEBUG_STATEBOX
+				std::cerr << "p3NetMgr::updateNetStateBox_startup() ";
+				std::cerr << "netAssist Returned: " << rs_inet_ntoa(tmpip.sin_addr);
+				std::cerr << ":" << ntohs(tmpip.sin_port);
+				std::cerr << std::endl;
+#endif
+				mNetStateBox.setAddressUPnP(true, &tmpip);
+			}
+			else
+			{
+				mNetStateBox.setAddressUPnP(false, &tmpip);
+#ifdef	NETMGR_DEBUG_STATEBOX
+				std::cerr << "p3NetMgr::updateNetStateBox_startup() ";
+				std::cerr << "ERROR Bad Address supplied from netAssistExternalAddress()";
+				std::cerr << std::endl;
+#endif
+			}
+		}
+		else
+		{
+#ifdef	NETMGR_DEBUG_STATEBOX
+			std::cerr << "p3NetMgr::updateNetStateBox_startup() ";
+			std::cerr << " netAssistExtAddress() is not active";
+			std::cerr << std::endl;
+#endif
+			mNetStateBox.setAddressUPnP(false, &tmpip);
+		}
+
+
+		/* ExtAddrFinder */
+		if (mUseExtAddrFinder)
+		{
+			bool extFinderOk = mExtAddrFinder->hasValidIP(&(tmpip.sin_addr));
+			if (extFinderOk)
+			{
+				/* best guess at port */
+				tmpip.sin_port = mNetFlags.mLocalAddr.sin_port;
+
+#ifdef	NETMGR_DEBUG_STATEBOX
+				std::cerr << "p3NetMgr::updateNetStateBox_startup() ";
+				std::cerr << "ExtAddrFinder Returned: " << rs_inet_ntoa(tmpip.sin_addr);
+				std::cerr << std::endl;
+#endif
+
+				mNetStateBox.setAddressWebIP(true, &tmpip);
+			}
+			else
+			{
+				mNetStateBox.setAddressWebIP(false, &tmpip);
+#ifdef	NETMGR_DEBUG_STATEBOX
+				std::cerr << "p3NetMgr::updateNetStateBox_startup() ";
+				std::cerr << " ExtAddrFinder hasn't found an address yet";
+				std::cerr << std::endl;
+#endif
+			}
+		}
+		else
+		{
+#ifdef	NETMGR_DEBUG_STATEBOX
+			std::cerr << "p3NetMgr::updateNetStateBox_startup() ";
+			std::cerr << " ExtAddrFinder is not active";
+			std::cerr << std::endl;
+#endif
+			mNetStateBox.setAddressWebIP(false, &tmpip);
+		}
+	}
+}
+
+void p3NetMgr::updateNetStateBox_reset()
+{
+	{
+		RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
+
+		mNetStateBox.reset();
+	}
+}
+
+	

libretroshare/src/pqi/p3netmgr.h

@@ -33,6 +33,8 @@
 //#include "pqi/p3upnpmgr.h"
 #include "pqi/pqiassist.h"
 
+#include "pqi/pqinetstatebox.h"
+
 #include "pqi/p3cfgmgr.h"
 
 #include "util/rsthreads.h"
@@ -98,6 +100,7 @@ void	setManagers(p3PeerMgr *peerMgr, p3LinkMgr *linkMgr);
 void	setAddrAssist(pqiAddrAssist *dhtStun, pqiAddrAssist *proxyStun);
 
 void 	tick();
+void 	slowTick();
 
 	/*************** Setup ***************************/
 void	addNetAssistConnect(uint32_t type, pqiNetAssistConnect *);
@@ -201,6 +204,13 @@ void 	netUpnpCheck();
 
 void    netUnreachableCheck();
 
+
+	/* net state via NetStateBox */
+void 	updateNetStateBox_temporal();
+void 	updateNetStateBox_startup();
+void 	updateNetStateBox_reset();
+void    updateNatSetting();
+
 private:
 	// These should have there own Mutex Protection,
 	ExtAddrFinder *mExtAddrFinder ;
@@ -238,6 +248,15 @@ void 	netStatusReset_locked();
 	/* network status flags (read by rsiface) */
 	pqiNetStatus mNetFlags;
 	pqiNetStatus mOldNetFlags;
+
+
+	// Improved NetStatusBox, which uses the Stunners!
+	pqiNetStateBox mNetStateBox;
+
+	time_t mLastSlowTickTime;
+	uint32_t mOldNatType;
+	uint32_t mOldNatHole;
+
 };
 
 #endif // MRK_PQI_NET_MANAGER_HEADER

libretroshare/src/pqi/p3peermgr.cc

@@ -65,8 +65,6 @@ const uint32_t PEER_IP_CONNECT_STATE_MAX_LIST_SIZE =     	4;
  * #define PEER_DEBUG 1
  ***/
 
-#define PEER_DEBUG 1
-
 #define MAX_AVAIL_PERIOD 230 //times a peer stay in available state when not connected
 #define MIN_RETRY_PERIOD 140
 

libretroshare/src/pqi/pqiassist.h

@@ -92,6 +92,8 @@ class pqiAddrAssist
 virtual	~pqiAddrAssist() { return; }
 
 virtual bool    getExternalAddr(struct sockaddr_in &remote, uint8_t &stable) = 0;
+virtual void    setRefreshPeriod(int32_t period) = 0;
+virtual int	tick() = 0; /* for internal accounting */
 
 };
 

libretroshare/src/pqi/pqinetstatebox.cc

@@ -1,8 +1,11 @@
 
+#include "retroshare/rsconfig.h"
 #include "util/rsnet.h"
 #include "pqi/pqinetstatebox.h"
 #include "time.h"
 
+#include <sstream>
+
 // External Interface.
 
 void pqiNetStateBox::setAddressStunDht(struct sockaddr_in *addr, bool stable)
@@ -141,14 +144,21 @@ uint32_t pqiNetStateBox::getNetStateMode()
 /******************************** Internal Workings *******************************/
 pqiNetStateBox::pqiNetStateBox()
 {
+	reset();
+}
+
+
+void pqiNetStateBox::reset()
+{
+
 	mStatusOkay = false;
 	//time_t mStatusTS;
 	
-	mNetworkMode = PNSB_NETWORK_UNKNOWN;
+	mNetworkMode = RSNET_NETWORK_UNKNOWN;
-	mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+	mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-	mNatHoleMode = PNSB_NATHOLE_UNKNOWN;
+	mNatHoleMode = RSNET_NATHOLE_UNKNOWN;
-	mConnectModes = PNSB_CONNECT_NONE;
+	mConnectModes = RSNET_CONNECT_NONE;
-	mNetStateMode = PNSB_NETSTATE_BAD_UNKNOWN;
+	mNetStateMode = RSNET_NETSTATE_BAD_UNKNOWN;
 	
 	/* Parameters set externally */
 	
@@ -242,11 +252,11 @@ void pqiNetStateBox::determineNetworkState()
 	   /* firstly lets try to identify OFFLINE / UNKNOWN */
 	   if ((!mStunProxySet) || (!mStunDhtSet))
 	   {
-		mNetworkMode = PNSB_NETWORK_UNKNOWN;
+		mNetworkMode = RSNET_NETWORK_UNKNOWN;
 		// Assume these.
-		mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+		mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-		mNatHoleMode = PNSB_NATHOLE_NONE;
+		mNatHoleMode = RSNET_NATHOLE_NONE;
-		mNetStateMode = PNSB_NETSTATE_BAD_UNKNOWN;
+		mNetStateMode = RSNET_NETSTATE_BAD_UNKNOWN;
 
 		//mExtAddress = .... unknown;
 		//mExtAddrStable = false;
@@ -261,10 +271,10 @@ void pqiNetStateBox::determineNetworkState()
 			if (!mStunProxyStable)
 			{
 				/* both unstable, Symmetric NAT, Firewalled, No UDP Hole */
-				mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+				mNetworkMode = RSNET_NETWORK_BEHINDNAT;
-				mNatTypeMode = PNSB_NATTYPE_SYMMETRIC;
+				mNatTypeMode = RSNET_NATTYPE_SYMMETRIC;
-				mNatHoleMode = PNSB_NATHOLE_NONE;
+				mNatHoleMode = RSNET_NATHOLE_NONE;
-				mNetStateMode = PNSB_NETSTATE_BAD_NATSYM;
+				mNetStateMode = RSNET_NETSTATE_BAD_NATSYM;
 			}
 			else
 			{
@@ -283,10 +293,10 @@ void pqiNetStateBox::determineNetworkState()
 				 * but that label is really fully accurate. (gray area).
 				 */
 
-				mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+				mNetworkMode = RSNET_NETWORK_BEHINDNAT;
-				mNatTypeMode = PNSB_NATTYPE_RESTRICTED_CONE;
+				mNatTypeMode = RSNET_NATTYPE_RESTRICTED_CONE;
-				mNatHoleMode = PNSB_NATHOLE_NONE;
+				mNatHoleMode = RSNET_NATHOLE_NONE;
-				mNetStateMode = PNSB_NETSTATE_WARNING_NATTED;
+				mNetStateMode = RSNET_NETSTATE_WARNING_NATTED;
 			}
 		}
 		else // Dht Stable.
@@ -309,39 +319,39 @@ void pqiNetStateBox::determineNetworkState()
 			if (!mStunProxyStable)
 			{
 				/* must be a forwarded port/ext or something similar */
-				mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+				mNetworkMode = RSNET_NETWORK_BEHINDNAT;
-				mNatTypeMode = PNSB_NATTYPE_SYMMETRIC;
+				mNatTypeMode = RSNET_NATTYPE_SYMMETRIC;
-				mNatHoleMode = PNSB_NATHOLE_FORWARDED;
+				mNatHoleMode = RSNET_NATHOLE_FORWARDED;
-				mNetStateMode = PNSB_NETSTATE_GOOD;
+				mNetStateMode = RSNET_NETSTATE_GOOD;
 			}
 			else
 			{
 				/* fallback is FULL CONE NAT */
-				mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+				mNetworkMode = RSNET_NETWORK_BEHINDNAT;
-				mNatTypeMode = PNSB_NATTYPE_FULL_CONE;
+				mNatTypeMode = RSNET_NATTYPE_FULL_CONE;
-				mNatHoleMode = PNSB_NATHOLE_NONE;
+				mNatHoleMode = RSNET_NATHOLE_NONE;
-				mNetStateMode = PNSB_NETSTATE_WARNING_NATTED;
+				mNetStateMode = RSNET_NETSTATE_WARNING_NATTED;
 			}
 
 			if (mUPnPActive)
 			{
 				// This Mode is OKAY.
-				mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+				mNetworkMode = RSNET_NETWORK_BEHINDNAT;
 				// Use Fallback Guess.
-				//mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+				//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-				mNatHoleMode = PNSB_NATHOLE_UPNP;
+				mNatHoleMode = RSNET_NATHOLE_UPNP;
-				mNetStateMode = PNSB_NETSTATE_GOOD;
+				mNetStateMode = RSNET_NETSTATE_GOOD;
 				//mExtAddress = ... from UPnP, should match StunDht.
 				//mExtAddrStable = true;
 			}
 			else if (mNatPMPActive)
 			{
 				// This Mode is OKAY.
-				mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+				mNetworkMode = RSNET_NETWORK_BEHINDNAT;
 				// Use Fallback Guess.
-				//mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+				//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-				mNatHoleMode = PNSB_NATHOLE_NATPMP;
+				mNatHoleMode = RSNET_NATHOLE_NATPMP;
-				mNetStateMode = PNSB_NETSTATE_GOOD;
+				mNetStateMode = RSNET_NETSTATE_GOOD;
 				//mExtAddress = ... from NatPMP, should match NatPMP
 				//mExtAddrStable = true;
 			}
@@ -351,20 +361,20 @@ void pqiNetStateBox::determineNetworkState()
 	
 				if (isExtAddress)
 				{
-					mNetworkMode = PNSB_NETWORK_EXTERNALIP;
+					mNetworkMode = RSNET_NETWORK_EXTERNALIP;
-					mNatTypeMode = PNSB_NATTYPE_NONE;
+					mNatTypeMode = RSNET_NATTYPE_NONE;
-					mNatHoleMode = PNSB_NATHOLE_NONE;
+					mNatHoleMode = RSNET_NATHOLE_NONE;
-					mNetStateMode = PNSB_NETSTATE_GOOD;
+					mNetStateMode = RSNET_NETSTATE_GOOD;
 	
 					//mExtAddrStable = true;
 				}
 				else if (mPortForwardedSet)
 				{
-					mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+					mNetworkMode = RSNET_NETWORK_BEHINDNAT;
 					// Use Fallback Guess.
-					//mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+					//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-					mNatHoleMode = PNSB_NATHOLE_FORWARDED;
+					mNatHoleMode = RSNET_NATHOLE_FORWARDED;
-					mNetStateMode = PNSB_NETSTATE_ADV_FORWARD;
+					mNetStateMode = RSNET_NETSTATE_ADV_FORWARD;
 	
 					//mExtAddrStable = true; // Probably, makin assumption.
 				}
@@ -388,22 +398,22 @@ void pqiNetStateBox::determineNetworkState()
 		if (mUPnPActive)
 		{
 			// This Mode is OKAY.
-			mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+			mNetworkMode = RSNET_NETWORK_BEHINDNAT;
-			mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+			mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-			mNatHoleMode = PNSB_NATHOLE_UPNP;
+			mNatHoleMode = RSNET_NATHOLE_UPNP;
 			//mExtAddress = ... from UPnP.
 			//mExtAddrStable = true;
-			mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
+			mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
 		}
 		else if (mNatPMPActive)
 		{
 			// This Mode is OKAY.
-			mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+			mNetworkMode = RSNET_NETWORK_BEHINDNAT;
-			mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+			mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-			mNatHoleMode = PNSB_NATHOLE_NATPMP;
+			mNatHoleMode = RSNET_NATHOLE_NATPMP;
 			//mExtAddress = ... from NatPMP.
 			//mExtAddrStable = true;
-			mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
+			mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
 		}
 		else 
 		{
@@ -415,21 +425,21 @@ void pqiNetStateBox::determineNetworkState()
 
 			if (isExtAddress)
 			{
-				mNetworkMode = PNSB_NETWORK_EXTERNALIP;
+				mNetworkMode = RSNET_NETWORK_EXTERNALIP;
-				mNatTypeMode = PNSB_NATTYPE_NONE;
+				mNatTypeMode = RSNET_NATTYPE_NONE;
-				mNatHoleMode = PNSB_NATHOLE_NONE;
+				mNatHoleMode = RSNET_NATHOLE_NONE;
 
 				//mExtAddrStable = true;
-				mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
+				mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
 			}
 			else if (mPortForwardedSet)
 			{
-				mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+				mNetworkMode = RSNET_NETWORK_BEHINDNAT;
-				mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+				mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-				mNatHoleMode = PNSB_NATHOLE_FORWARDED;
+				mNatHoleMode = RSNET_NATHOLE_FORWARDED;
 
 				//mExtAddrStable = true; // Probably, makin assumption.
-				mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
+				mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
 			}
 			else
 			{
@@ -437,10 +447,10 @@ void pqiNetStateBox::determineNetworkState()
 				 * These people have destroyed the possibility of making connections ;(
 				 * Should WARN about this.
 				 */ 
-				mNetworkMode = PNSB_NETWORK_BEHINDNAT;
+				mNetworkMode = RSNET_NETWORK_BEHINDNAT;
-				mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
+				mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
-				mNatHoleMode = PNSB_NATHOLE_NONE;
+				mNatHoleMode = RSNET_NATHOLE_NONE;
-				mNetStateMode = PNSB_NETSTATE_BAD_NODHT_NAT;
+				mNetStateMode = RSNET_NETSTATE_BAD_NODHT_NAT;
 
 				//mExtAddrStable = false; // Unlikely to be stable.
 			}
@@ -462,42 +472,42 @@ void pqiNetStateBox::determineNetworkState()
 void pqiNetStateBox::workoutNetworkMode()
 {
 	/* connectModes are dependent on the other modes */
-	mConnectModes = PNSB_CONNECT_NONE;
+	mConnectModes = RSNET_CONNECT_NONE;
 	switch(mNetworkMode)
 	{
-		case PNSB_NETWORK_UNKNOWN:
+		case RSNET_NETWORK_UNKNOWN:
-		case PNSB_NETWORK_OFFLINE:
+		case RSNET_NETWORK_OFFLINE:
-		case PNSB_NETWORK_LOCALNET:
+		case RSNET_NETWORK_LOCALNET:
 			/* nothing here */
 			break;
-		case PNSB_NETWORK_EXTERNALIP:
+		case RSNET_NETWORK_EXTERNALIP:
-			mConnectModes = PNSB_CONNECT_OUTGOING_TCP;
+			mConnectModes = RSNET_CONNECT_OUTGOING_TCP;
-			mConnectModes |= PNSB_CONNECT_ACCEPT_TCP;
+			mConnectModes |= RSNET_CONNECT_ACCEPT_TCP;
 
 			if (mDhtActive)
 			{
-				mConnectModes |= PNSB_CONNECT_DIRECT_UDP;
+				mConnectModes |= RSNET_CONNECT_DIRECT_UDP;
 				/* if open port. don't want PROXY or RELAY connect 
 				 * because we should be able to do direct with EVERYONE.
 				 * Ability to do Proxy is dependent on FIREWALL status.
 				 * Technically could do RELAY, but disable both.
 				 */
-				//mConnectModes |= PNSB_CONNECT_PROXY_UDP;
+				//mConnectModes |= RSNET_CONNECT_PROXY_UDP;
-				//mConnectModes |= PNSB_CONNECT_RELAY_UDP;
+				//mConnectModes |= RSNET_CONNECT_RELAY_UDP;
 			}
 			break;
-		case PNSB_NETWORK_BEHINDNAT:
+		case RSNET_NETWORK_BEHINDNAT:
-			mConnectModes = PNSB_CONNECT_OUTGOING_TCP;
+			mConnectModes = RSNET_CONNECT_OUTGOING_TCP;
 
 			/* we're okay if there's a NAT HOLE */
-			if ((mNatHoleMode == PNSB_NATHOLE_UPNP) ||
+			if ((mNatHoleMode == RSNET_NATHOLE_UPNP) ||
-				(mNatHoleMode == PNSB_NATHOLE_NATPMP) ||
+				(mNatHoleMode == RSNET_NATHOLE_NATPMP) ||
-				(mNatHoleMode == PNSB_NATHOLE_FORWARDED))
+				(mNatHoleMode == RSNET_NATHOLE_FORWARDED))
 			{
-				mConnectModes |= PNSB_CONNECT_ACCEPT_TCP;
+				mConnectModes |= RSNET_CONNECT_ACCEPT_TCP;
 				if (mDhtActive)
 				{
-					mConnectModes |= PNSB_CONNECT_DIRECT_UDP;
+					mConnectModes |= RSNET_CONNECT_DIRECT_UDP;
 					/* dont want PROXY | RELAY with open ports */
 				}
 			}
@@ -509,13 +519,13 @@ void pqiNetStateBox::workoutNetworkMode()
 			    */
 			   if (mDhtActive)
 			   {
-				mConnectModes |= PNSB_CONNECT_DIRECT_UDP;
+				mConnectModes |= RSNET_CONNECT_DIRECT_UDP;
-				mConnectModes |= PNSB_CONNECT_RELAY_UDP;
+				mConnectModes |= RSNET_CONNECT_RELAY_UDP;
 
-				if ((mNatTypeMode == PNSB_NATTYPE_RESTRICTED_CONE) ||
+				if ((mNatTypeMode == RSNET_NATTYPE_RESTRICTED_CONE) ||
-				    (mNatTypeMode == PNSB_NATTYPE_FULL_CONE))
+				    (mNatTypeMode == RSNET_NATTYPE_FULL_CONE))
 				{
-					mConnectModes |= PNSB_CONNECT_PROXY_UDP;
+					mConnectModes |= RSNET_CONNECT_PROXY_UDP;
 				}
 			   }
 			}
@@ -523,3 +533,157 @@ void pqiNetStateBox::workoutNetworkMode()
 	}
 }
 
+
+
+
+std::string NetStateNetworkModeString(uint32_t netMode)
+{
+	std::string str;
+	switch(netMode)
+	{
+		default:
+		case RSNET_NETWORK_UNKNOWN:
+			str = "Unknown NetState";
+		break;
+		case RSNET_NETWORK_OFFLINE:
+			str = "Offline";
+		break;
+		case RSNET_NETWORK_LOCALNET:
+			str = "Local Net";
+		break;
+		case RSNET_NETWORK_BEHINDNAT:
+			str = "Behind NAT";
+		break;
+		case RSNET_NETWORK_EXTERNALIP:
+			str = "External IP";
+		break;
+	}
+	return str;
+}
+
+std::string NetStateNatTypeString(uint32_t natType)
+{
+	std::string str;
+	switch(natType)
+	{
+		default:
+		case RSNET_NATTYPE_UNKNOWN:
+			str = "UNKNOWN NAT STATE";
+		break;
+		case RSNET_NATTYPE_SYMMETRIC:
+			str = "SYMMETRIC NAT";
+		break;
+		case RSNET_NATTYPE_RESTRICTED_CONE:
+			str = "RESTRICTED CONE NAT";
+		break;
+		case RSNET_NATTYPE_FULL_CONE:
+			str = "FULL CONE NAT";
+		break;
+		case RSNET_NATTYPE_OTHER:
+			str = "OTHER NAT";
+		break;
+		case RSNET_NATTYPE_NONE:
+			str = "NO NAT";
+		break;
+	}
+	return str;
+}
+
+		
+std::string NetStateNatHoleString(uint32_t natHole)
+{
+	std::string str;
+	switch(natHole)
+	{
+		default:
+		case RSNET_NATHOLE_UNKNOWN:
+			str = "UNKNOWN NAT HOLE STATUS";
+		break;
+		case RSNET_NATHOLE_NONE:
+			str = "NO NAT HOLE";
+		break;
+		case RSNET_NATHOLE_UPNP:
+			str = "UPNP FORWARD";
+		break;
+		case RSNET_NATHOLE_NATPMP:
+			str = "NATPMP FORWARD";
+		break;
+		case RSNET_NATHOLE_FORWARDED:
+			str = "MANUAL FORWARD";
+		break;
+	}
+	return str;
+}
+
+
+std::string NetStateConnectModesString(uint32_t connect)
+{
+	std::ostringstream 	connOut;
+	if (connect & RSNET_CONNECT_OUTGOING_TCP)
+	{
+		connOut << "TCP_OUT ";
+	}
+	if (connect & RSNET_CONNECT_ACCEPT_TCP)
+	{
+		connOut << "TCP_IN ";
+	}
+	if (connect & RSNET_CONNECT_DIRECT_UDP)
+	{
+		connOut << "DIRECT_UDP ";
+	}
+	if (connect & RSNET_CONNECT_PROXY_UDP)
+	{
+		connOut << "PROXY_UDP ";
+	}
+	if (connect & RSNET_CONNECT_RELAY_UDP)
+	{
+		connOut << "RELAY_UDP ";
+	}
+	return connOut.str();
+}
+
+
+
+std::string NetStateNetStateString(uint32_t netstate)
+{
+	std::string str;
+	switch(netstate)
+	{
+		case RSNET_NETSTATE_BAD_UNKNOWN:
+			str = "NET BAD: Unknown State";
+		break;
+		case RSNET_NETSTATE_BAD_OFFLINE:
+			str = "NET BAD: Offline";
+		break;
+		case RSNET_NETSTATE_BAD_NATSYM:
+			str = "NET BAD: Behind Symmetric NAT";
+		break;
+		case RSNET_NETSTATE_BAD_NODHT_NAT:
+			str = "NET BAD: Behind NAT & No DHT";
+		break;
+		case RSNET_NETSTATE_WARNING_RESTART:
+			str = "NET WARNING: NET Restart";
+		break;
+		case RSNET_NETSTATE_WARNING_NATTED:
+			str = "NET WARNING: Behind NAT";
+		break;
+		case RSNET_NETSTATE_WARNING_NODHT:
+			str = "NET WARNING: No DHT";
+		break;
+		case RSNET_NETSTATE_GOOD:
+			str = "NET STATE GOOD!";
+		break;
+		case RSNET_NETSTATE_ADV_FORWARD:
+			str = "CAUTION: UNVERIFABLE FORWARD!";
+		break;
+		case RSNET_NETSTATE_ADV_DARK_FORWARD:
+			str = "CAUTION: UNVERIFABLE FORWARD & NO DHT";
+		break;
+	}
+	return str;
+}
+
+
+
+
+

libretroshare/src/pqi/pqinetstatebox.h

@@ -13,62 +13,13 @@
  *
  */
 
-#define PNSB_NETWORK_UNKNOWN		1
-#define PNSB_NETWORK_RESTARTING		2
-#define PNSB_NETWORK_OFFLINE		3
-#define PNSB_NETWORK_LOCALNET		4
-#define PNSB_NETWORK_BEHINDNAT		5
-#define PNSB_NETWORK_EXTERNALIP		6
-
-// WHAT TYPE OF FIREWALL?
-#define PNSB_NATTYPE_NONE			1
-#define PNSB_NATTYPE_UNKNOWN			2
-#define PNSB_NATTYPE_SYMMETRIC 			3
-#define PNSB_NATTYPE_RESTRICTED_CONE		4
-#define PNSB_NATTYPE_FULL_CONE			5
-#define PNSB_NATTYPE_OTHER			6
-
-// WHAT TYPE OF HOLE?
-#define PNSB_NATHOLE_UNKNOWN		0		
-#define PNSB_NATHOLE_NONE		1		
-#define PNSB_NATHOLE_UPNP		2	
-#define PNSB_NATHOLE_NATPMP		3
-#define PNSB_NATHOLE_FORWARDED		4
-
-// Types of Connections.
-#define PNSB_CONNECT_NONE		0x0000
-#define PNSB_CONNECT_ACCEPT_TCP		0x0001
-#define PNSB_CONNECT_OUTGOING_TCP	0x0002
-#define PNSB_CONNECT_DIRECT_UDP		0x0100
-#define PNSB_CONNECT_PROXY_UDP		0x0200
-#define PNSB_CONNECT_RELAY_UDP		0x0400
-
-// net state (good, okay, bad)
-// BAD. (RED)
-#define PNSB_NETSTATE_BAD_UNKNOWN	1
-#define PNSB_NETSTATE_BAD_OFFLINE	2
-#define PNSB_NETSTATE_BAD_NATSYM	3
-#define PNSB_NETSTATE_BAD_NODHT_NAT	4
-
-// CAUTION. (ORANGE)
-#define PNSB_NETSTATE_WARNING_RESTART	5
-#define PNSB_NETSTATE_WARNING_NATTED	6
-#define PNSB_NETSTATE_WARNING_NODHT	7
-
-// GOOD (GREEN)
-// NAT with forwarded port, or EXT port.
-#define PNSB_NETSTATE_GOOD		8
-
-// ADVANCED MODE (BLUE)
-// If the user knows what they are doing... we cannot confirm this.
-#define PNSB_NETSTATE_ADV_FORWARD	9
-#define PNSB_NETSTATE_ADV_DARK_FORWARD	10
-
 class pqiNetStateBox
 {
 	public:
 	pqiNetStateBox();
 
+	void reset();
+
 	/* input network bits */
 	void setAddressStunDht(struct sockaddr_in *, bool stable);
 	void setAddressStunProxy(struct sockaddr_in *, bool stable);
@@ -141,4 +92,13 @@ class pqiNetStateBox
 	uint16_t  mPortForwarded;
 };
 
+
+
+std::string NetStateNetStateString(uint32_t netstate);
+std::string NetStateConnectModesString(uint32_t connect);
+std::string NetStateNatHoleString(uint32_t natHole);
+std::string NetStateNatTypeString(uint32_t natType);
+std::string NetStateNetworkModeString(uint32_t netMode);
+
+
 #endif

libretroshare/src/tcponudp/udpstunner.cc

@@ -31,12 +31,14 @@
 
 static const int STUN_TTL = 64;
 
-#define TOU_STUN_MIN_PEERS 5
+#define TOU_STUN_MIN_PEERS 20
 
 /*
  * #define DEBUG_UDP_STUNNER 1
+ * #define DEBUG_UDP_STUNNER_FILTER 1
  */
-//#define DEBUG_UDP_STUNNER 1
+
+#define DEBUG_UDP_STUNNER 1
 
 const int32_t TOU_STUN_MAX_FAIL_COUNT = 3; /* 3 tries (could be higher?) */
 const int32_t TOU_STUN_MAX_SEND_RATE = 5;  /* every 5  seconds */
@@ -78,19 +80,27 @@ void	UdpStunner::SetAcceptLocalNet()
 
 #endif
 
-void	UdpStunner::setTargetStunPeriod(uint32_t sec_per_stun)
+void	UdpStunner::setTargetStunPeriod(int32_t sec_per_stun)
 {
         RsStackMutex stack(stunMtx);   /********** LOCK MUTEX *********/
 
-	if (sec_per_stun == 0)
+	if (sec_per_stun < 0)
 	{
-		mPassiveStunMode = true;
+		mPassiveStunMode = false;
+		mTargetStunPeriod = TOU_STUN_DEFAULT_TARGET_RATE;
 	}
 	else
 	{
-		mPassiveStunMode = false;
+		if (sec_per_stun == 0)
+		{
+			mPassiveStunMode = true;
+		}
+		else
+		{
+			mPassiveStunMode = false;
+		}
+		mTargetStunPeriod = sec_per_stun;
 	}
-	mTargetStunPeriod = sec_per_stun;
 
 }
 
@@ -98,7 +108,7 @@ void	UdpStunner::setTargetStunPeriod(uint32_t sec_per_stun)
 int UdpStunner::recvPkt(void *data, int size, struct sockaddr_in &from)
 {
 	/* print packet information */
-#ifdef DEBUG_UDP_STUNNER
+#ifdef DEBUG_UDP_STUNNER_FILTER
 	std::cerr << "UdpStunner::recvPkt(" << size << ") from: " << from;
 	std::cerr << std::endl;
 #endif
@@ -109,7 +119,7 @@ int UdpStunner::recvPkt(void *data, int size, struct sockaddr_in &from)
 	if (UdpStun_isStunPacket(data, size))
 	{
 		mStunLastRecvAny = time(NULL);
-#ifdef DEBUG_UDP_STUNNER
+#ifdef DEBUG_UDP_STUNNER_FILTER
 		std::cerr << "UdpStunner::recvPkt() is Stun Packet";
 		std::cerr << std::endl;
 #endif
@@ -153,6 +163,9 @@ int UdpStunner::tick()
 	if (checkStunDesired())
 	{
 		attemptStun();
+#ifdef DEBUG_UDP_STUNNER
+		status(std::cerr);
+#endif
 	}
 
 	return 1;
@@ -331,7 +344,7 @@ bool    UdpStun_response(void *stun_pkt, int size, struct sockaddr_in &addr)
 	addr.sin_port = ((uint16_t *) stun_pkt)[11];
 
 
-#ifdef DEBUG_UDP_STUNNER
+#ifdef DEBUG_UDP_STUNNER_FILTER
 	std::ostringstream out;
 	out << "UdpStunner::response() Recvd a Stun Response, ext_addr: ";
 	out << inet_ntoa(addr.sin_addr) << ":" << ntohs(addr.sin_port);
@@ -390,14 +403,14 @@ void *UdpStun_generate_stun_reply(struct sockaddr_in *stun_addr, int *len)
 
 bool UdpStun_isStunPacket(void *data, int size)
 {
-#ifdef DEBUG_UDP_STUNNER
+#ifdef DEBUG_UDP_STUNNER_FILTER
 	std::cerr << "UdpStunner::isStunPacket() ?";
 	std::cerr << std::endl;
 #endif
 
 	if (size < 20)
 	{
-#ifdef DEBUG_UDP_STUNNER
+#ifdef DEBUG_UDP_STUNNER_FILTER
 		std::cerr << "UdpStunner::isStunPacket() (size < 20) -> false";
 		std::cerr << std::endl;
 #endif
@@ -408,7 +421,7 @@ bool UdpStun_isStunPacket(void *data, int size)
 	uint16_t pktsize = ntohs(((uint16_t *) data)[1]);
 	if (size != pktsize)
 	{
-#ifdef DEBUG_UDP_STUNNER
+#ifdef DEBUG_UDP_STUNNER_FILTER
 		std::cerr << "UdpStunner::isStunPacket() (size != pktsize) -> false";
 		std::cerr << std::endl;
 #endif
@@ -417,7 +430,7 @@ bool UdpStun_isStunPacket(void *data, int size)
 
 	if ((size == 20) && (0x0001 == ntohs(((uint16_t *) data)[0])))
 	{
-#ifdef DEBUG_UDP_STUNNER
+#ifdef DEBUG_UDP_STUNNER_FILTER
 		std::cerr << "UdpStunner::isStunPacket() (size=20 & data[0]=0x0001) -> true";
 		std::cerr << std::endl;
 #endif
@@ -427,7 +440,7 @@ bool UdpStun_isStunPacket(void *data, int size)
 
 	if ((size == 28) && (0x0101 == ntohs(((uint16_t *) data)[0])))
 	{
-#ifdef DEBUG_UDP_STUNNER
+#ifdef DEBUG_UDP_STUNNER_FILTER
 		std::cerr << "UdpStunner::isStunPacket() (size=28 & data[0]=0x0101) -> true";
 		std::cerr << std::endl;
 #endif

libretroshare/src/tcponudp/udpstunner.h

@@ -83,7 +83,7 @@ virtual ~UdpStunner() { return; }
 	void SetAcceptLocalNet();
 #endif
 
-void 	setTargetStunPeriod(uint32_t sec_per_stun);
+void 	setTargetStunPeriod(int32_t sec_per_stun);
 bool    addStunPeer(const struct sockaddr_in &remote, const char *peerid);
 bool    getStunPeer(int idx, std::string &id,
                 struct sockaddr_in &remote, struct sockaddr_in &eaddr,