Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-02-26 09:41:29 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Integrated NetStateBox and Activated Stunners.

Browse Source 
* 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
This commit is contained in:
drbob 2011-07-12 14:16:46 +00:00
parent 52cbe0f2fb
commit 6c5d5f6cc2
10 changed files with 684 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
libretroshare/src/dht/stunaddrassist.h
View File

@ -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;

3
libretroshare/src/pqi/p3linkmgr.cc
View File

@ -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

392
libretroshare/src/pqi/p3netmgr.cc
View File

@ -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();
}
}

19
libretroshare/src/pqi/p3netmgr.h
View File

@ -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

2
libretroshare/src/pqi/p3peermgr.cc
View File

@ -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

2
libretroshare/src/pqi/pqiassist.h
View File

@ -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 */
};

330
libretroshare/src/pqi/pqinetstatebox.cc
View File

@ -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;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_UNKNOWN;
mConnectModes = PNSB_CONNECT_NONE;
mNetStateMode = PNSB_NETSTATE_BAD_UNKNOWN;
mNetworkMode = RSNET_NETWORK_UNKNOWN;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_UNKNOWN;
mConnectModes = RSNET_CONNECT_NONE;
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;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_BAD_UNKNOWN;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_NONE;
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;
mNatTypeMode = PNSB_NATTYPE_SYMMETRIC;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_BAD_NATSYM;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_SYMMETRIC;
mNatHoleMode = RSNET_NATHOLE_NONE;
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;
mNatTypeMode = PNSB_NATTYPE_RESTRICTED_CONE;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_WARNING_NATTED;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_RESTRICTED_CONE;
mNatHoleMode = RSNET_NATHOLE_NONE;
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;
mNatTypeMode = PNSB_NATTYPE_SYMMETRIC;
mNatHoleMode = PNSB_NATHOLE_FORWARDED;
mNetStateMode = PNSB_NETSTATE_GOOD;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_SYMMETRIC;
mNatHoleMode = RSNET_NATHOLE_FORWARDED;
mNetStateMode = RSNET_NETSTATE_GOOD;
}
else
{
/* fallback is FULL CONE NAT */
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_FULL_CONE;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_WARNING_NATTED;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_FULL_CONE;
mNatHoleMode = RSNET_NATHOLE_NONE;
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;
mNatHoleMode = PNSB_NATHOLE_UPNP;
mNetStateMode = PNSB_NETSTATE_GOOD;
//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_UPNP;
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;
mNatHoleMode = PNSB_NATHOLE_NATPMP;
mNetStateMode = PNSB_NETSTATE_GOOD;
//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_NATPMP;
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;
mNatTypeMode = PNSB_NATTYPE_NONE;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_GOOD;
mNetworkMode = RSNET_NETWORK_EXTERNALIP;
mNatTypeMode = RSNET_NATTYPE_NONE;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetStateMode = RSNET_NETSTATE_GOOD;
//mExtAddrStable = true;
}
else if (mPortForwardedSet)
{
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
// Use Fallback Guess.
//mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_FORWARDED;
mNetStateMode = PNSB_NETSTATE_ADV_FORWARD;
//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_FORWARDED;
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;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_UPNP;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
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;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_NATPMP;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
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;
mNatTypeMode = PNSB_NATTYPE_NONE;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetworkMode = RSNET_NETWORK_EXTERNALIP;
mNatTypeMode = RSNET_NATTYPE_NONE;
mNatHoleMode = RSNET_NATHOLE_NONE;
//mExtAddrStable = true;
mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
}
else if (mPortForwardedSet)
{
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_FORWARDED;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
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;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_BAD_NODHT_NAT;
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_NONE;
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 PNSB_NETWORK_OFFLINE:
case PNSB_NETWORK_LOCALNET:
case RSNET_NETWORK_UNKNOWN:
case RSNET_NETWORK_OFFLINE:
case RSNET_NETWORK_LOCALNET:
/* nothing here */
break;
case PNSB_NETWORK_EXTERNALIP:
mConnectModes = PNSB_CONNECT_OUTGOING_TCP;
mConnectModes |= PNSB_CONNECT_ACCEPT_TCP;
case RSNET_NETWORK_EXTERNALIP:
mConnectModes = RSNET_CONNECT_OUTGOING_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 |= PNSB_CONNECT_RELAY_UDP;
//mConnectModes |= RSNET_CONNECT_PROXY_UDP;
//mConnectModes |= RSNET_CONNECT_RELAY_UDP;
}
break;
case PNSB_NETWORK_BEHINDNAT:
mConnectModes = PNSB_CONNECT_OUTGOING_TCP;
case RSNET_NETWORK_BEHINDNAT:
mConnectModes = RSNET_CONNECT_OUTGOING_TCP;
/* we're okay if there's a NAT HOLE */
if ((mNatHoleMode == PNSB_NATHOLE_UPNP) ||
(mNatHoleMode == PNSB_NATHOLE_NATPMP) ||
(mNatHoleMode == PNSB_NATHOLE_FORWARDED))
if ((mNatHoleMode == RSNET_NATHOLE_UPNP) ||
(mNatHoleMode == RSNET_NATHOLE_NATPMP) ||
(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 |= PNSB_CONNECT_RELAY_UDP;
mConnectModes |= RSNET_CONNECT_DIRECT_UDP;
mConnectModes |= RSNET_CONNECT_RELAY_UDP;
if ((mNatTypeMode == PNSB_NATTYPE_RESTRICTED_CONE) ||
(mNatTypeMode == PNSB_NATTYPE_FULL_CONE))
if ((mNatTypeMode == RSNET_NATTYPE_RESTRICTED_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;
}

62
libretroshare/src/pqi/pqinetstatebox.h
View File

@ -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

43
libretroshare/src/tcponudp/udpstunner.cc
View File

@ -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

2
libretroshare/src/tcponudp/udpstunner.h
View File

@ -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,