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

Merge remote-tracking branch 'upstream/master' into v0.6-TorV3

Browse source
This commit is contained in:
csoler 2020-10-10 23:12:27 +02:00
commit 74660b916a
119 changed files with 1012 additions and 1284 deletions
Download patch file Download diff file Expand all files Collapse all files

21
libretroshare/src/dht/connectstatebox.cc
View file

@ -21,7 +21,6 @@
*******************************************************************************/
#include "dht/connectstatebox.h"
#include "retroshare/rsconfig.h"
#include "util/rsrandom.h"
#include "util/rsstring.h"
@ -260,26 +259,26 @@ std::string PeerConnectStateBox::connectState() const
}
uint32_t convertNetStateToInternal(uint32_t netmode, uint32_t nathole, uint32_t nattype)
uint32_t convertNetStateToInternal(RsNetworkMode netmode, RsNatHoleMode nathole, RsNatTypeMode nattype)
{
uint32_t connNet = CSB_NETSTATE_UNKNOWN;
if (netmode == RSNET_NETWORK_EXTERNALIP)
if (netmode == RsNetworkMode::EXTERNALIP)
{
connNet = CSB_NETSTATE_FORWARD;
}
else if ((nathole != RSNET_NATHOLE_UNKNOWN) && (nathole != RSNET_NATHOLE_NONE))
else if ((nathole != RsNatHoleMode::UNKNOWN) && (nathole != RsNatHoleMode::NONE))
{
connNet = CSB_NETSTATE_FORWARD;
}
else if (netmode == RSNET_NETWORK_BEHINDNAT)
else if (netmode == RsNetworkMode::BEHINDNAT)
{
if ((nattype == RSNET_NATTYPE_RESTRICTED_CONE) ||
(nattype == RSNET_NATTYPE_FULL_CONE))
if ((nattype == RsNatTypeMode::RESTRICTED_CONE) ||
(nattype == RsNatTypeMode::FULL_CONE))
{
connNet = CSB_NETSTATE_STABLENAT;
}
else if (nattype == RSNET_NATTYPE_DETERM_SYM)
else if (nattype == RsNatTypeMode::DETERM_SYM)
{
connNet = CSB_NETSTATE_EXCLUSIVENAT;
}
@ -300,20 +299,20 @@ bool shouldUseProxyPortInternal(uint32_t netstate)
return true;
}
bool PeerConnectStateBox::shouldUseProxyPort(uint32_t netmode, uint32_t nathole, uint32_t nattype)
bool PeerConnectStateBox::shouldUseProxyPort(RsNetworkMode netmode, RsNatHoleMode nathole, RsNatTypeMode nattype)
{
uint32_t netstate = convertNetStateToInternal(netmode, nathole, nattype);
return shouldUseProxyPortInternal(netstate);
}
uint32_t PeerConnectStateBox::calcNetState(uint32_t netmode, uint32_t nathole, uint32_t nattype)
uint32_t PeerConnectStateBox::calcNetState(RsNetworkMode netmode, RsNatHoleMode nathole, RsNatTypeMode nattype)
{
uint32_t netstate = convertNetStateToInternal(netmode, nathole, nattype);
return netstate;
}
uint32_t PeerConnectStateBox::connectCb(uint32_t cbtype, uint32_t netmode, uint32_t nathole, uint32_t nattype)
uint32_t PeerConnectStateBox::connectCb(uint32_t cbtype, RsNetworkMode netmode, RsNatHoleMode nathole, RsNatTypeMode nattype)
{
uint32_t netstate = convertNetStateToInternal(netmode, nathole, nattype);

8
libretroshare/src/dht/connectstatebox.h
View file

@ -75,17 +75,19 @@
#include "util/rstime.h"
#include <inttypes.h>
#include <retroshare/rsconfig.h>
class PeerConnectStateBox
{
public:
PeerConnectStateBox();
uint32_t connectCb(uint32_t cbtype, uint32_t netmode, uint32_t nathole, uint32_t nattype);
uint32_t connectCb(uint32_t cbtype, RsNetworkMode netmode, RsNatHoleMode nathole, RsNatTypeMode nattype);
uint32_t updateCb(uint32_t updateType);
bool shouldUseProxyPort(uint32_t netmode, uint32_t nathole, uint32_t nattype);
bool shouldUseProxyPort(RsNetworkMode netmode, RsNatHoleMode nathole, RsNatTypeMode nattype);
uint32_t calcNetState(uint32_t netmode, uint32_t nathole, uint32_t nattype);
uint32_t calcNetState(RsNetworkMode netmode, RsNatHoleMode nathole, RsNatTypeMode nattype);
std::string connectState() const;
std::string mPeerId;

22
libretroshare/src/dht/p3bitdht.h
View file

@ -45,20 +45,20 @@ class DhtPeerDetails
DhtPeerDetails();
uint32_t mPeerType;
RsDhtPeerType mPeerType;
bdId mDhtId;
RsPeerId mRsId;
/* direct from the DHT! */
uint32_t mDhtState; // One of RSDHT_PEERDHT_[...]
RsDhtPeerDht mDhtState;
rstime_t mDhtUpdateTS;
/* internal state */
PeerConnectStateBox mConnectLogic;
/* Actual Connection Status */
uint32_t mPeerConnectState; // One of RSDHT_PEERCONN_
RsDhtPeerConnectState mPeerConnectState;
std::string mPeerConnectMsg;
uint32_t mPeerConnectMode;
bdId mPeerConnectPeerId;
@ -77,7 +77,7 @@ class DhtPeerDetails
/* Connection Request Status */
std::string mPeerReqStatusMsg;
uint32_t mPeerReqState;
RsDhtPeerRequest mPeerReqState;
uint32_t mPeerReqMode;
bdId mPeerReqProxyId;
rstime_t mPeerReqTS;
@ -294,11 +294,11 @@ public:
virtual int addRelayServer(std::string ids);
virtual int removeRelayServer(std::string ids);
virtual uint32_t getRelayMode();
virtual int setRelayMode(uint32_t mode);
virtual RsDhtRelayMode getRelayMode();
virtual int setRelayMode(RsDhtRelayMode mode);
virtual int getRelayAllowance(int classIdx, uint32_t &count, uint32_t &bandwidth);
virtual int setRelayAllowance(int classIdx, uint32_t count, uint32_t bandwidth);
virtual int getRelayAllowance(RsDhtRelayClass classIdx, uint32_t &count, uint32_t &bandwidth);
virtual int setRelayAllowance(RsDhtRelayClass classIdx, uint32_t count, uint32_t bandwidth);
private:
@ -307,7 +307,7 @@ private:
int pushRelayServers();
std::list<std::string> mRelayServerList;
uint32_t mRelayMode;
RsDhtRelayMode mRelayMode;
protected:
/*****************************************************************/
@ -348,9 +348,9 @@ public:
private:
DhtPeerDetails *addInternalPeer_locked(const RsPeerId& pid, uint32_t type);
DhtPeerDetails *addInternalPeer_locked(const RsPeerId& pid, RsDhtPeerType type);
int removeInternalPeer_locked(const RsPeerId& pid);
DhtPeerDetails *findInternalDhtPeer_locked(const bdNodeId *id, uint32_t type);
DhtPeerDetails *findInternalDhtPeer_locked(const bdNodeId *id, RsDhtPeerType type);
DhtPeerDetails *findInternalRsPeer_locked(const RsPeerId &pid);
bool havePeerTranslation_locked(const RsPeerId &pid);

8
libretroshare/src/dht/p3bitdht_interface.cc
View file

@ -302,16 +302,16 @@ void convertDhtPeerDetailsToRsDhtNetPeer(RsDhtNetPeer &status, const DhtPeerDeta
switch(details.mPeerConnectMode)
{
default:
status.mPeerConnectMode = RSDHT_TOU_MODE_NONE;
status.mPeerConnectMode = RsDhtTouMode::NONE;
break;
case BITDHT_CONNECT_MODE_DIRECT:
status.mPeerConnectMode = RSDHT_TOU_MODE_DIRECT;
status.mPeerConnectMode = RsDhtTouMode::DIRECT;
break;
case BITDHT_CONNECT_MODE_PROXY:
status.mPeerConnectMode = RSDHT_TOU_MODE_PROXY;
status.mPeerConnectMode = RsDhtTouMode::PROXY;
break;
case BITDHT_CONNECT_MODE_RELAY:
status.mPeerConnectMode = RSDHT_TOU_MODE_RELAY;
status.mPeerConnectMode = RsDhtTouMode::RELAY;
break;
}

106
libretroshare/src/dht/p3bitdht_peernet.cc
View file

@ -83,7 +83,7 @@ int p3BitDht::InfoCallback(const bdId *id, uint32_t /*type*/, uint32_t /*flags*/
{
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(id->id), RSDHT_PEERTYPE_ANY);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(id->id), RsDhtPeerType::ANY);
if (dpd)
{
@ -204,7 +204,7 @@ int p3BitDht::PeerCallback(const bdId *id, uint32_t status)
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(id->id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(id->id), RsDhtPeerType::FRIEND);
if (!dpd)
{
@ -222,26 +222,26 @@ int p3BitDht::PeerCallback(const bdId *id, uint32_t status)
switch(status)
{
default:
dpd->mDhtState = RSDHT_PEERDHT_NOT_ACTIVE;
dpd->mDhtState = RsDhtPeerDht::NOT_ACTIVE;
break;
case BITDHT_MGR_QUERY_FAILURE:
dpd->mDhtState = RSDHT_PEERDHT_FAILURE;
dpd->mDhtState = RsDhtPeerDht::FAILURE;
break;
case BITDHT_MGR_QUERY_PEER_OFFLINE:
dpd->mDhtState = RSDHT_PEERDHT_OFFLINE;
dpd->mDhtState = RsDhtPeerDht::OFFLINE;
break;
case BITDHT_MGR_QUERY_PEER_UNREACHABLE:
dpd->mDhtState = RSDHT_PEERDHT_UNREACHABLE;
dpd->mDhtState = RsDhtPeerDht::UNREACHABLE;
dpd->mDhtId = *id; // set the IP:Port of the unreachable peer.
UnreachablePeerCallback_locked(id, status, dpd);
break;
case BITDHT_MGR_QUERY_PEER_ONLINE:
dpd->mDhtState = RSDHT_PEERDHT_ONLINE;
dpd->mDhtState = RsDhtPeerDht::ONLINE;
dpd->mDhtId = *id; // set the IP:Port of the Online peer.
OnlinePeerCallback_locked(id, status, dpd);
@ -262,8 +262,8 @@ int p3BitDht::OnlinePeerCallback_locked(const bdId *id, uint32_t /*status*/, Dht
/* remove unused parameter warnings */
(void) id;
if ((dpd->mPeerConnectState != RSDHT_PEERCONN_DISCONNECTED) ||
(dpd->mPeerReqState == RSDHT_PEERREQ_RUNNING))
if ((dpd->mPeerConnectState != RsDhtPeerConnectState::DISCONNECTED) ||
(dpd->mPeerReqState == RsDhtPeerRequest::RUNNING))
{
#ifdef DEBUG_PEERNET
@ -367,8 +367,8 @@ int p3BitDht::OnlinePeerCallback_locked(const bdId *id, uint32_t /*status*/, Dht
int p3BitDht::UnreachablePeerCallback_locked(const bdId *id, uint32_t /*status*/, DhtPeerDetails *dpd)
{
if ((dpd->mPeerConnectState != RSDHT_PEERCONN_DISCONNECTED) ||
(dpd->mPeerReqState == RSDHT_PEERREQ_RUNNING))
if ((dpd->mPeerConnectState != RsDhtPeerConnectState::DISCONNECTED) ||
(dpd->mPeerReqState == RsDhtPeerRequest::RUNNING))
{
#ifdef DEBUG_PEERNET
@ -717,7 +717,7 @@ int p3BitDht::ConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId
std::cerr << std::endl;
#endif
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId.id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId.id), RsDhtPeerType::FRIEND);
if (dpd)
{
proxyPort = dpd->mConnectLogic.shouldUseProxyPort(
@ -811,7 +811,7 @@ int p3BitDht::ConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId
std::cerr << std::endl;
#endif
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId.id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId.id), RsDhtPeerType::FRIEND);
if (dpd)
{
dpd->mExclusiveProxyLock = true;
@ -939,7 +939,7 @@ int p3BitDht::ConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId.id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId.id), RsDhtPeerType::FRIEND);
if (dpd)
{
dpd->mPeerCbMsg = "ERROR : ";
@ -980,7 +980,7 @@ int p3BitDht::ConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId.id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId.id), RsDhtPeerType::FRIEND);
if (dpd)
{
if (errcode)
@ -989,7 +989,7 @@ int p3BitDht::ConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId
dpd->mPeerReqStatusMsg = "STOPPED: ";
dpd->mPeerReqStatusMsg += decodeConnectionError(errcode);
dpd->mPeerReqState = RSDHT_PEERREQ_STOPPED;
dpd->mPeerReqState = RsDhtPeerRequest::STOPPED;
dpd->mPeerReqTS = now;
int updatecode = CSB_UPDATE_FAILED_ATTEMPT;
@ -1048,7 +1048,7 @@ int p3BitDht::ConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId
else // a new connection attempt.
{
dpd->mPeerReqStatusMsg = "Connect Attempt";
dpd->mPeerReqState = RSDHT_PEERREQ_RUNNING;
dpd->mPeerReqState = RsDhtPeerRequest::RUNNING;
dpd->mPeerReqMode = mode;
dpd->mPeerReqProxyId = *proxyId;
dpd->mPeerReqTS = now;
@ -1232,7 +1232,7 @@ int p3BitDht::doActions()
{
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mDestId.id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mDestId.id), RsDhtPeerType::FRIEND);
if (dpd)
{
connectOk = true;
@ -1387,11 +1387,11 @@ int p3BitDht::doActions()
#endif
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mDestId.id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mDestId.id), RsDhtPeerType::FRIEND);
if (dpd)
{
dpd->mPeerReqStatusMsg = "Connect Request";
dpd->mPeerReqState = RSDHT_PEERREQ_RUNNING;
dpd->mPeerReqState = RsDhtPeerRequest::RUNNING;
dpd->mPeerReqMode = action.mMode;
dpd->mPeerReqTS = now;
@ -1428,13 +1428,13 @@ int p3BitDht::doActions()
//}
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mDestId.id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mDestId.id), RsDhtPeerType::FRIEND);
if (dpd)
{
dpd->mConnectLogic.updateCb(failReason);
dpd->mPeerReqStatusMsg = "Req Mode Unavailable";
dpd->mPeerReqState = RSDHT_PEERREQ_STOPPED;
dpd->mPeerReqState = RsDhtPeerRequest::STOPPED;
dpd->mPeerReqMode = action.mMode;
dpd->mPeerReqTS = now;
@ -1496,7 +1496,7 @@ int p3BitDht::doActions()
{
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mSrcId.id), RSDHT_PEERTYPE_ANY);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mSrcId.id), RsDhtPeerType::ANY);
if (dpd)
{
if (action.mAnswer)
@ -1604,7 +1604,7 @@ int p3BitDht::doActions()
{
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mDestId.id), RSDHT_PEERTYPE_ANY);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(action.mDestId.id), RsDhtPeerType::ANY);
if (dpd)
{
peerRsId = dpd->mRsId;
@ -1730,7 +1730,7 @@ int p3BitDht::checkConnectionAllowed(const bdId *peerId, int mode)
rstime_t now = time(NULL);
/* check if they are in our friend list */
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId->id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerId->id), RsDhtPeerType::FRIEND);
if (!dpd)
{
#ifdef DEBUG_PEERNET
@ -1749,14 +1749,14 @@ int p3BitDht::checkConnectionAllowed(const bdId *peerId, int mode)
/* flag as failed */
it->second.mDhtId = *peerId;
it->second.mDhtState = RSDHT_PEERDHT_NOT_ACTIVE;
it->second.mDhtState = RsDhtPeerDht::NOT_ACTIVE;
it->second.mDhtUpdateTS = now;
it->second.mPeerType = RSDHT_PEERTYPE_OTHER;
it->second.mPeerType = RsDhtPeerType::OTHER;
it->second.mPeerCbMsg = "Denied Non-Friend";
it->second.mPeerReqStatusMsg = "Denied Non-Friend";
it->second.mPeerReqState = RSDHT_PEERREQ_STOPPED;
it->second.mPeerReqState = RsDhtPeerRequest::STOPPED;
it->second.mPeerReqTS = now;
it->second.mPeerReqMode = 0;
//it->second.mPeerProxyId;
@ -1765,7 +1765,7 @@ int p3BitDht::checkConnectionAllowed(const bdId *peerId, int mode)
it->second.mPeerCbMsg = "Denied Non-Friend";
it->second.mPeerConnectMsg = "Denied Non-Friend";
it->second.mPeerConnectState = RSDHT_PEERCONN_DISCONNECTED;
it->second.mPeerConnectState = RsDhtPeerConnectState::DISCONNECTED;
return 0;
@ -1774,7 +1774,7 @@ int p3BitDht::checkConnectionAllowed(const bdId *peerId, int mode)
/* are a friend */
if (dpd->mPeerConnectState == RSDHT_PEERCONN_CONNECTED)
if (dpd->mPeerConnectState == RsDhtPeerConnectState::CONNECTED)
{
std::cerr << "p3BitDht::checkConnectionAllowed() ERROR Peer Already Connected, DENIED";
std::cerr << std::endl;
@ -1979,7 +1979,7 @@ void p3BitDht::initiateConnection(const bdId *srcId, const bdId *proxyId, const
{
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerConnectId.id), RSDHT_PEERTYPE_FRIEND);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&(peerConnectId.id), RsDhtPeerType::FRIEND);
/* grab a socket */
if (!dpd)
{
@ -1988,7 +1988,7 @@ void p3BitDht::initiateConnection(const bdId *srcId, const bdId *proxyId, const
return;
}
if (dpd->mPeerConnectState != RSDHT_PEERCONN_DISCONNECTED)
if (dpd->mPeerConnectState != RsDhtPeerConnectState::DISCONNECTED)
{
std::cerr << "p3BitDht::initiateConnection() ERROR Peer is not Disconnected";
std::cerr << std::endl;
@ -2003,7 +2003,7 @@ void p3BitDht::initiateConnection(const bdId *srcId, const bdId *proxyId, const
{
default:
case BITDHT_CONNECT_MODE_DIRECT:
// touConnectMode = RSDHT_TOU_MODE_DIRECT;
// touConnectMode = RsDhtTouMode::DIRECT;
connectFlags |= RS_CB_FLAG_MODE_UDP_DIRECT;
delay = delayOrBandwidth;
break;
@ -2021,12 +2021,12 @@ void p3BitDht::initiateConnection(const bdId *srcId, const bdId *proxyId, const
delay = delayOrBandwidth;
if (useProxyPort)
{
// touConnectMode = RSDHT_TOU_MODE_PROXY;
// touConnectMode = RsDhtTouMode::PROXY;
connectFlags |= RS_CB_FLAG_MODE_UDP_PROXY;
}
else
{
// touConnectMode = RSDHT_TOU_MODE_DIRECT;
// touConnectMode = RsDhtTouMode::DIRECT;
connectFlags |= RS_CB_FLAG_MODE_UDP_DIRECT;
}
@ -2034,7 +2034,7 @@ void p3BitDht::initiateConnection(const bdId *srcId, const bdId *proxyId, const
break;
case BITDHT_CONNECT_MODE_RELAY:
// touConnectMode = RSDHT_TOU_MODE_RELAY;
// touConnectMode = RsDhtTouMode::RELAY;
connectFlags |= RS_CB_FLAG_MODE_UDP_RELAY;
bandwidth = delayOrBandwidth;
break;
@ -2047,7 +2047,7 @@ void p3BitDht::initiateConnection(const bdId *srcId, const bdId *proxyId, const
/* store results in Status */
dpd->mPeerConnectMsg = "UDP started";
dpd->mPeerConnectState = RSDHT_PEERCONN_UDP_STARTED;
dpd->mPeerConnectState = RsDhtPeerConnectState::UDP_STARTED;
dpd->mPeerConnectUdpTS = time(NULL);
dpd->mPeerConnectMode = mode;
dpd->mPeerConnectPoint = loc;
@ -2092,22 +2092,22 @@ int p3BitDht::installRelayConnection(const bdId *srcId, const bdId *destId, uint
#endif
/* grab a socket */
DhtPeerDetails *dpd_src = findInternalDhtPeer_locked(&(srcId->id), RSDHT_PEERTYPE_ANY);
DhtPeerDetails *dpd_dest = findInternalDhtPeer_locked(&(destId->id), RSDHT_PEERTYPE_ANY);
DhtPeerDetails *dpd_src = findInternalDhtPeer_locked(&(srcId->id), RsDhtPeerType::ANY);
DhtPeerDetails *dpd_dest = findInternalDhtPeer_locked(&(destId->id), RsDhtPeerType::ANY);
if ((dpd_src) && (dpd_src->mPeerType == RSDHT_PEERTYPE_FRIEND))
if ((dpd_src) && (dpd_src->mPeerType == RsDhtPeerType::FRIEND))
{
relayClass = UDP_RELAY_CLASS_FRIENDS;
}
else if ((dpd_dest) && (dpd_dest->mPeerType == RSDHT_PEERTYPE_FRIEND))
else if ((dpd_dest) && (dpd_dest->mPeerType == RsDhtPeerType::FRIEND))
{
relayClass = UDP_RELAY_CLASS_FRIENDS;
}
else if ((dpd_src) && (dpd_src->mPeerType == RSDHT_PEERTYPE_FOF))
else if ((dpd_src) && (dpd_src->mPeerType == RsDhtPeerType::FOF))
{
relayClass = UDP_RELAY_CLASS_FOF;
}
else if ((dpd_dest) && (dpd_dest->mPeerType == RSDHT_PEERTYPE_FOF))
else if ((dpd_dest) && (dpd_dest->mPeerType == RsDhtPeerType::FOF))
{
relayClass = UDP_RELAY_CLASS_FOF;
}
@ -2178,12 +2178,12 @@ void p3BitDht::monitorConnections()
for(it = mPeers.begin(); it != mPeers.end(); ++it)
{
/* ignore ones which aren't friends */
if (it->second.mPeerType != RSDHT_PEERTYPE_FRIEND)
if (it->second.mPeerType != RsDhtPeerType::FRIEND)
{
continue;
}
if (it->second.mPeerConnectState == RSDHT_PEERCONN_UDP_STARTED)
if (it->second.mPeerConnectState == RsDhtPeerConnectState::UDP_STARTED)
{
#ifdef DEBUG_PEERNET
std::cerr << "p3BitDht::monitorConnections() Connection in progress to: ";
@ -2225,7 +2225,7 @@ void p3BitDht::Feedback_Connected(const RsPeerId& pid)
}
/* sanity checking */
if (dpd->mPeerConnectState != RSDHT_PEERCONN_UDP_STARTED)
if (dpd->mPeerConnectState != RsDhtPeerConnectState::UDP_STARTED)
{
/* ERROR */
std::cerr << "p3BitDht::Feedback_Connected() ERROR not in UDP_STARTED mode for: ";
@ -2242,7 +2242,7 @@ void p3BitDht::Feedback_Connected(const RsPeerId& pid)
#endif
/* switch state! */
dpd->mPeerConnectState = RSDHT_PEERCONN_CONNECTED;
dpd->mPeerConnectState = RsDhtPeerConnectState::CONNECTED;
dpd->mPeerConnectTS = time(NULL);
dpd->mConnectLogic.updateCb(CSB_UPDATE_CONNECTED);
@ -2250,7 +2250,7 @@ void p3BitDht::Feedback_Connected(const RsPeerId& pid)
rs_sprintf(dpd->mPeerConnectMsg, "Connected in %ld secs", dpd->mPeerConnectTS - dpd->mPeerConnectUdpTS);
// Remove the Connection Request.
if (dpd->mPeerReqState == RSDHT_PEERREQ_RUNNING)
if (dpd->mPeerReqState == RsDhtPeerRequest::RUNNING)
{
#ifdef DEBUG_PEERNET
std::cerr << "p3BitDht::monitorConnections() Request Active, Stopping Request";
@ -2334,7 +2334,7 @@ void p3BitDht::Feedback_ConnectionClosed(const RsPeerId& pid)
void p3BitDht::UdpConnectionFailed_locked(DhtPeerDetails *dpd)
{
if (dpd->mPeerConnectState == RSDHT_PEERCONN_UDP_STARTED)
if (dpd->mPeerConnectState == RsDhtPeerConnectState::UDP_STARTED)
{
#ifdef DEBUG_PEERNET
std::cerr << "p3BitDht::UdpConnectionFailed_locked() UDP Connection Failed: ";
@ -2345,11 +2345,11 @@ void p3BitDht::UdpConnectionFailed_locked(DhtPeerDetails *dpd)
/* shut it down */
/* ONLY need to update ConnectLogic - if it was our Attempt Running */
if (dpd->mPeerReqState == RSDHT_PEERREQ_RUNNING)
if (dpd->mPeerReqState == RsDhtPeerRequest::RUNNING)
{
dpd->mConnectLogic.updateCb(CSB_UPDATE_FAILED_ATTEMPT);
}
dpd->mPeerConnectState = RSDHT_PEERCONN_DISCONNECTED;
dpd->mPeerConnectState = RsDhtPeerConnectState::DISCONNECTED;
dpd->mPeerConnectMsg = "UDP Failed";
}
@ -2363,14 +2363,14 @@ void p3BitDht::UdpConnectionFailed_locked(DhtPeerDetails *dpd)
dpd->mConnectLogic.updateCb(CSB_UPDATE_DISCONNECTED);
dpd->mPeerConnectState = RSDHT_PEERCONN_DISCONNECTED;
dpd->mPeerConnectState = RsDhtPeerConnectState::DISCONNECTED;
dpd->mPeerConnectClosedTS = time(NULL);
rs_sprintf(dpd->mPeerConnectMsg, "Closed, Alive for: %ld secs", dpd->mPeerConnectClosedTS - dpd->mPeerConnectTS);
}
if (dpd->mPeerReqState == RSDHT_PEERREQ_RUNNING)
if (dpd->mPeerReqState == RsDhtPeerRequest::RUNNING)
{
#ifdef DEBUG_PEERNET
std::cerr << "p3BitDht::UdpConnectionFailed_locked() ";

54
libretroshare/src/dht/p3bitdht_peers.cc
View file

@ -64,7 +64,7 @@ bool p3BitDht::findPeer(const RsPeerId& pid)
DhtPeerDetails *dpd = findInternalRsPeer_locked(pid);
if (!dpd)
{
dpd = addInternalPeer_locked(pid, RSDHT_PEERTYPE_FRIEND);
dpd = addInternalPeer_locked(pid, RsDhtPeerType::FRIEND);
if (!dpd)
{
/* ERROR */
@ -76,7 +76,7 @@ bool p3BitDht::findPeer(const RsPeerId& pid)
}
/* new entry... what do we need to set? */
dpd->mDhtState = RSDHT_PEERDHT_SEARCHING;
dpd->mDhtState = RsDhtPeerDht::SEARCHING;
#ifdef DEBUG_BITDHT
std::cerr << "p3BitDht::findPeer() Installed new DhtPeer with pid => NodeId: ";
@ -93,7 +93,7 @@ bool p3BitDht::findPeer(const RsPeerId& pid)
std::cerr << std::endl;
#endif
if (dpd->mDhtState != RSDHT_PEERDHT_NOT_ACTIVE)
if (dpd->mDhtState != RsDhtPeerDht::NOT_ACTIVE)
{
#ifdef DEBUG_BITDHT
std::cerr << "p3BitDht::findPeer() WARNING DhtState is Already Active!";
@ -104,7 +104,7 @@ bool p3BitDht::findPeer(const RsPeerId& pid)
else
{
/* flag as searching */
dpd->mDhtState = RSDHT_PEERDHT_SEARCHING;
dpd->mDhtState = RsDhtPeerDht::SEARCHING;
#ifdef DEBUG_BITDHT
std::cerr << "p3BitDht::findPeer() Marking Old Peer as SEARCHING";
std::cerr << std::endl;
@ -150,13 +150,13 @@ bool p3BitDht::dropPeer(const RsPeerId& pid)
#endif
//addFriend(pid);
dpd = addInternalPeer_locked(pid, RSDHT_PEERTYPE_FOF);
dpd = addInternalPeer_locked(pid, RsDhtPeerType::FOF);
return false;
}
/* flag as searching */
dpd->mDhtState = RSDHT_PEERDHT_NOT_ACTIVE;
dpd->mDhtState = RsDhtPeerDht::NOT_ACTIVE;
nid = dpd->mDhtId.id;
@ -242,7 +242,7 @@ int p3BitDht::addKnownPeer( const RsPeerId &pid,
addrv4.sin_addr = ap->sin_addr;
addrv4.sin_port = ap->sin_port;
int p3type = 0;
RsDhtPeerType p3type = RsDhtPeerType::ANY;
int bdflags = 0;
bdId id;
bool isOwnId = false;
@ -253,27 +253,27 @@ int p3BitDht::addKnownPeer( const RsPeerId &pid,
return 0;
break;
case NETASSIST_KNOWN_PEER_WHITELIST:
p3type = RSDHT_PEERTYPE_OTHER;
p3type = RsDhtPeerType::OTHER;
bdflags = BITDHT_PEER_STATUS_DHT_WHITELIST;
break;
case NETASSIST_KNOWN_PEER_FOF:
p3type = RSDHT_PEERTYPE_FOF;
p3type = RsDhtPeerType::FOF;
bdflags = BITDHT_PEER_STATUS_DHT_FOF;
break;
case NETASSIST_KNOWN_PEER_FRIEND:
p3type = RSDHT_PEERTYPE_FRIEND;
p3type = RsDhtPeerType::FRIEND;
bdflags = BITDHT_PEER_STATUS_DHT_FRIEND;
break;
case NETASSIST_KNOWN_PEER_RELAY:
p3type = RSDHT_PEERTYPE_OTHER;
p3type = RsDhtPeerType::OTHER;
bdflags = BITDHT_PEER_STATUS_DHT_RELAY_SERVER;
break;
case NETASSIST_KNOWN_PEER_SELF:
p3type = RSDHT_PEERTYPE_OTHER;
p3type = RsDhtPeerType::OTHER;
bdflags = BITDHT_PEER_STATUS_DHT_SELF;
isOwnId = true;
@ -364,7 +364,7 @@ int p3BitDht::addFriend(const std::string pid)
{
RsStackMutex stack(dhtMtx); /********* LOCKED *********/
return (NULL != addInternalPeer_locked(pid, RSDHT_PEERTYPE_FRIEND));
return (NULL != addInternalPeer_locked(pid, RsDhtPeerType::FRIEND));
}
@ -372,7 +372,7 @@ int p3BitDht::addFriendOfFriend(const std::string pid)
{
RsStackMutex stack(dhtMtx); /********* LOCKED *********/
return (NULL != addInternalPeer_locked(pid, RSDHT_PEERTYPE_FOF));
return (NULL != addInternalPeer_locked(pid, RsDhtPeerType::FOF));
}
@ -380,7 +380,7 @@ int p3BitDht::addOther(const std::string pid)
{
RsStackMutex stack(dhtMtx); /********* LOCKED *********/
return (NULL != addInternalPeer_locked(pid, RSDHT_PEERTYPE_OTHER));
return (NULL != addInternalPeer_locked(pid, RsDhtPeerType::OTHER));
}
#endif
@ -397,7 +397,7 @@ int p3BitDht::removePeer(const RsPeerId& pid)
********************************* Basic Peer Details *************************************
******************************************************************************************/
DhtPeerDetails *p3BitDht::addInternalPeer_locked(const RsPeerId& pid, uint32_t type)
DhtPeerDetails *p3BitDht::addInternalPeer_locked(const RsPeerId& pid, RsDhtPeerType type)
{
/* create the data structure */
if (!havePeerTranslation_locked(pid))
@ -411,18 +411,18 @@ DhtPeerDetails *p3BitDht::addInternalPeer_locked(const RsPeerId& pid, uint32_t t
return 0;
}
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&id, RSDHT_PEERTYPE_ANY);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&id, RsDhtPeerType::ANY);
if (!dpd)
{
DhtPeerDetails newdpd;
newdpd.mDhtId.id = id;
newdpd.mRsId = pid;
newdpd.mDhtState = RSDHT_PEERDHT_NOT_ACTIVE;
newdpd.mPeerType = RSDHT_PEERTYPE_ANY;
newdpd.mDhtState = RsDhtPeerDht::NOT_ACTIVE;
newdpd.mPeerType = RsDhtPeerType::ANY;
mPeers[id] = newdpd;
dpd = findInternalDhtPeer_locked(&id, RSDHT_PEERTYPE_ANY);
dpd = findInternalDhtPeer_locked(&id, RsDhtPeerType::ANY);
if(dpd == NULL)
{
@ -462,14 +462,14 @@ int p3BitDht::removeInternalPeer_locked(const RsPeerId& pid)
/* indexed by bdNodeId, as this is the more used call interface */
DhtPeerDetails *p3BitDht::findInternalDhtPeer_locked(const bdNodeId *id, uint32_t type)
DhtPeerDetails *p3BitDht::findInternalDhtPeer_locked(const bdNodeId *id, RsDhtPeerType type)
{
std::map<bdNodeId, DhtPeerDetails>::iterator it = mPeers.find(*id);
if (it == mPeers.end())
{
return NULL;
}
if (type)
if (type != RsDhtPeerType::ANY)
{
if (it->second.mPeerType != type)
{
@ -495,7 +495,7 @@ DhtPeerDetails *p3BitDht::findInternalRsPeer_locked(const RsPeerId &pid)
return NULL;
}
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&id,RSDHT_PEERTYPE_ANY);
DhtPeerDetails *dpd = findInternalDhtPeer_locked(&id,RsDhtPeerType::ANY);
return dpd;
}
@ -717,13 +717,13 @@ int p3BitDht::calculateNodeId(const RsPeerId& pid, bdNodeId *id)
DhtPeerDetails::DhtPeerDetails()
{
mDhtState = RSDHT_PEERDHT_NOT_ACTIVE;
mDhtState = RsDhtPeerDht::NOT_ACTIVE;
mDhtState = RSDHT_PEERDHT_SEARCHING;
mDhtState = RsDhtPeerDht::SEARCHING;
mDhtUpdateTS = time(NULL);
mPeerReqStatusMsg = "Just Added";
mPeerReqState = RSDHT_PEERREQ_STOPPED;
mPeerReqState = RsDhtPeerRequest::STOPPED;
mPeerReqMode = 0;
//mPeerReqProxyId;
mPeerReqTS = time(NULL);
@ -737,7 +737,7 @@ DhtPeerDetails::DhtPeerDetails()
//mPeerCbDestId = 0;
mPeerCbTS = 0;
mPeerConnectState = RSDHT_PEERCONN_DISCONNECTED;
mPeerConnectState = RsDhtPeerConnectState::DISCONNECTED;
mPeerConnectMsg = "Disconnected";
mPeerConnectMode = 0;
//dpd->mPeerConnectProxyId;

44
libretroshare/src/dht/p3bitdht_relay.cc
View file

@ -35,7 +35,7 @@
int p3BitDht::setupRelayDefaults()
{
uint32_t mode = RSDHT_RELAY_ENABLED | RSDHT_RELAY_MODE_OFF;
RsDhtRelayMode mode = RsDhtRelayMode::ENABLED | RsDhtRelayMode::OFF;
setRelayMode(mode);
return 1;
@ -111,19 +111,19 @@ int p3BitDht::pushRelayServers()
}
uint32_t p3BitDht::getRelayMode()
RsDhtRelayMode p3BitDht::getRelayMode()
{
RsStackMutex stack(dhtMtx); /*********** LOCKED **********/
return mRelayMode;
}
int p3BitDht::setRelayMode(uint32_t mode)
int p3BitDht::setRelayMode(RsDhtRelayMode mode)
{
std::cerr << "p3BitDht::setRelayMode(" << mode << ")";
std::cerr << std::endl;
if (mode & RSDHT_RELAY_ENABLED)
if (!!(mode & RsDhtRelayMode::ENABLED))
{
mUdpBitDht->ConnectionOptions(
BITDHT_CONNECT_MODE_DIRECT | BITDHT_CONNECT_MODE_PROXY | BITDHT_CONNECT_MODE_RELAY,
@ -136,18 +136,18 @@ int p3BitDht::setRelayMode(uint32_t mode)
BITDHT_CONNECT_OPTION_AUTOPROXY);
}
int relaymode = mode & RSDHT_RELAY_MODE_MASK;
RsDhtRelayMode relaymode = mode & RsDhtRelayMode::MASK;
switch(relaymode)
{
case RSDHT_RELAY_MODE_OFF:
case RsDhtRelayMode::OFF:
mUdpBitDht->setDhtMode(BITDHT_MODE_RELAYSERVERS_IGNORED);
break;
case RSDHT_RELAY_MODE_ON:
case RsDhtRelayMode::ON:
pushRelayServers();
mUdpBitDht->setDhtMode(BITDHT_MODE_RELAYSERVERS_FLAGGED);
break;
case RSDHT_RELAY_MODE_SERVER:
case RsDhtRelayMode::SERVER:
pushRelayServers();
mUdpBitDht->setDhtMode(BITDHT_MODE_RELAYSERVERS_SERVER);
break;
@ -163,13 +163,13 @@ int p3BitDht::setRelayMode(uint32_t mode)
return 1;
}
int p3BitDht::getRelayAllowance(int classIdx, uint32_t &count, uint32_t &bandwidth)
int p3BitDht::getRelayAllowance(RsDhtRelayClass classIdx, uint32_t &count, uint32_t &bandwidth)
{
std::cerr << "p3BitDht::getRelayAllowance(" << classIdx << "): ";
if ((classIdx >= 0) && (classIdx < RSDHT_RELAY_NUM_CLASS))
std::cerr << "p3BitDht::getRelayAllowance(" << static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(classIdx) << "): ";
if ((classIdx >= RsDhtRelayClass::ALL) && (classIdx < RsDhtRelayClass::NUM_CLASS))
{
count = mRelay->getRelayClassMax(classIdx);
bandwidth = mRelay->getRelayClassBandwidth(classIdx);
count = mRelay->getRelayClassMax(static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(classIdx));
bandwidth = mRelay->getRelayClassBandwidth(static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(classIdx));
std::cerr << " count: " << count << " bandwidth: " << bandwidth;
std::cerr << std::endl;
@ -181,13 +181,13 @@ int p3BitDht::getRelayAllowance(int classIdx, uint32_t &count, uint32_t &bandwid
return 0;
}
int p3BitDht::setRelayAllowance(int classIdx, uint32_t count, uint32_t bandwidth)
int p3BitDht::setRelayAllowance(RsDhtRelayClass classIdx, uint32_t count, uint32_t bandwidth)
{
std::cerr << "p3BitDht::getRelayAllowance(" << classIdx << ", ";
std::cerr << "p3BitDht::getRelayAllowance(" << static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(classIdx) << ", ";
std::cerr << ", " << count << ", " << bandwidth << ")";
std::cerr << std::endl;
int retval = mRelay->setRelayClassMax(classIdx, count, bandwidth);
int retval = mRelay->setRelayClassMax(static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(classIdx), count, bandwidth);
IndicateConfigChanged();
return retval;
@ -224,7 +224,7 @@ bool p3BitDht::saveList(bool &cleanup, std::list<RsItem *> &saveList)
/* Push Relay Class Stuff */
int i;
for(i = 0; i < RSDHT_RELAY_NUM_CLASS; ++i)
for(i = 0; i < static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::NUM_CLASS); ++i)
{
rs_sprintf(kv.key, "RELAY_CLASS%d_COUNT", i);
rs_sprintf(kv.value, "%d", mRelay->getRelayClassMax(i));
@ -302,11 +302,11 @@ bool p3BitDht::loadList(std::list<RsItem *>& load)
//config->print(std::cerr, 0);
std::list<std::string> servers;
int peers[RSDHT_RELAY_NUM_CLASS] = {0};
int bandwidth[RSDHT_RELAY_NUM_CLASS] = {0};
int peers[static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::NUM_CLASS)] = {0};
int bandwidth[static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::NUM_CLASS)] = {0};
bool haveMode = false;
int mode = 0;
RsDhtRelayMode mode = RsDhtRelayMode::DISABLED;
std::list<RsTlvKeyValue>::iterator it;
for(it = config->tlvkvs.pairs.begin(); it != config->tlvkvs.pairs.end(); ++it)
@ -322,7 +322,7 @@ bool p3BitDht::loadList(std::list<RsItem *>& load)
}
else if (0 == strncmp(key.c_str(), "RELAY_MODE", 10))
{
mode = atoi(value.c_str());
mode = static_cast<RsDhtRelayMode>(atoi(value.c_str()));
haveMode = true;
//std::cerr << "p3BitDht::loadList() Found Mode: " << mode;
@ -386,7 +386,7 @@ bool p3BitDht::loadList(std::list<RsItem *>& load)
}
int i;
for(i = 0; i < RSDHT_RELAY_NUM_CLASS; ++i)
for(i = 0; i < static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::NUM_CLASS); ++i)
{
mRelay->setRelayClassMax(i, peers[i], bandwidth[i]);
}

8
libretroshare/src/pqi/p3linkmgr.cc
View file

@ -1063,8 +1063,12 @@ void p3LinkMgrIMPL::peerStatus(const RsPeerId& id, const pqiIpAddrSet &addrs,
uint32_t peer_vs_dht = 0;
uint32_t peerNetMode = 0;
uint32_t ownNetMode = mNetMgr->getNetworkMode();
int ownNetMode;
{
peerState ps;
mPeerMgr->getOwnNetStatus(ps);
ownNetMode = ps.netMode;
}
{
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/

54
libretroshare/src/pqi/p3netmgr.cc
View file

@ -124,8 +124,8 @@ p3NetMgrIMPL::p3NetMgrIMPL() : mPeerMgr(nullptr), mLinkMgr(nullptr),
mNetFlags = pqiNetStatus();
mOldNetFlags = pqiNetStatus();
mOldNatType = RSNET_NATTYPE_UNKNOWN;
mOldNatHole = RSNET_NATHOLE_UNKNOWN;
mOldNatType = RsNatTypeMode::UNKNOWN;
mOldNatHole = RsNatHoleMode::UNKNOWN;
sockaddr_storage_clear(mLocalAddr);
sockaddr_storage_clear(mExtAddr);
@ -1629,31 +1629,31 @@ void p3NetMgrIMPL::setIPServersEnabled(bool b)
************************************** NetStateBox ******************************************
**********************************************************************************************/
uint32_t p3NetMgrIMPL::getNetStateMode()
RsNetState p3NetMgrIMPL::getNetStateMode()
{
RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
return mNetStateBox.getNetStateMode();
}
uint32_t p3NetMgrIMPL::getNetworkMode()
RsNetworkMode p3NetMgrIMPL::getNetworkMode()
{
RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
return mNetStateBox.getNetworkMode();
}
uint32_t p3NetMgrIMPL::getNatTypeMode()
RsNatTypeMode p3NetMgrIMPL::getNatTypeMode()
{
RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
return mNetStateBox.getNatTypeMode();
}
uint32_t p3NetMgrIMPL::getNatHoleMode()
RsNatHoleMode p3NetMgrIMPL::getNatHoleMode()
{
RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
return mNetStateBox.getNatHoleMode();
}
uint32_t p3NetMgrIMPL::getConnectModes()
RsConnectModes p3NetMgrIMPL::getConnectModes()
{
RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
return mNetStateBox.getConnectModes();
@ -1768,8 +1768,8 @@ void p3NetMgrIMPL::updateNetStateBox_temporal()
void p3NetMgrIMPL::updateNatSetting()
{
bool updateRefreshRate = false;
uint32_t natType = RSNET_NATTYPE_UNKNOWN;
uint32_t natHole = RSNET_NATHOLE_UNKNOWN;
RsNatTypeMode natType = RsNatTypeMode::UNKNOWN;
RsNatHoleMode natHole = RsNatHoleMode::UNKNOWN;
{
RsStackMutex stack(mNetMtx); /****** STACK LOCK MUTEX *******/
@ -1806,9 +1806,9 @@ void p3NetMgrIMPL::updateNatSetting()
if (mProxyStunner) {
switch(natType)
{
case RSNET_NATTYPE_RESTRICTED_CONE:
case RsNatTypeMode::RESTRICTED_CONE:
{
if ((natHole == RSNET_NATHOLE_NONE) || (natHole == RSNET_NATHOLE_UNKNOWN))
if ((natHole == RsNatHoleMode::NONE) || (natHole == RsNatHoleMode::UNKNOWN))
{
mProxyStunner->setRefreshPeriod(NET_STUNNER_PERIOD_FAST);
}
@ -1818,12 +1818,12 @@ void p3NetMgrIMPL::updateNatSetting()
}
break;
}
case RSNET_NATTYPE_NONE:
case RSNET_NATTYPE_UNKNOWN:
case RSNET_NATTYPE_SYMMETRIC:
case RSNET_NATTYPE_DETERM_SYM:
case RSNET_NATTYPE_FULL_CONE:
case RSNET_NATTYPE_OTHER:
case RsNatTypeMode::NONE:
case RsNatTypeMode::UNKNOWN:
case RsNatTypeMode::SYMMETRIC:
case RsNatTypeMode::DETERM_SYM:
case RsNatTypeMode::FULL_CONE:
case RsNatTypeMode::OTHER:
mProxyStunner->setRefreshPeriod(NET_STUNNER_PERIOD_SLOW);
break;
@ -1836,22 +1836,22 @@ void p3NetMgrIMPL::updateNatSetting()
* So that messages can get through.
* We only want to be attached - if we don't have a stable DHT port.
*/
if ((natHole == RSNET_NATHOLE_NONE) || (natHole == RSNET_NATHOLE_UNKNOWN))
if ((natHole == RsNatHoleMode::NONE) || (natHole == RsNatHoleMode::UNKNOWN))
{
switch(natType)
{
/* switch to attach mode if we have a bad firewall */
case RSNET_NATTYPE_UNKNOWN:
case RSNET_NATTYPE_SYMMETRIC:
case RSNET_NATTYPE_RESTRICTED_CONE:
case RSNET_NATTYPE_DETERM_SYM:
case RSNET_NATTYPE_OTHER:
case RsNatTypeMode::UNKNOWN:
case RsNatTypeMode::SYMMETRIC:
case RsNatTypeMode::RESTRICTED_CONE:
case RsNatTypeMode::DETERM_SYM:
case RsNatTypeMode::OTHER:
netAssistAttach(true);
break;
/* switch off attach mode if we have a nice firewall */
case RSNET_NATTYPE_NONE:
case RSNET_NATTYPE_FULL_CONE:
case RsNatTypeMode::NONE:
case RsNatTypeMode::FULL_CONE:
netAssistAttach(false);
break;
}
@ -1970,8 +1970,8 @@ void p3NetMgrIMPL::updateNetStateBox_reset()
mNetStateBox.reset();
mOldNatHole = RSNET_NATHOLE_UNKNOWN;
mOldNatType = RSNET_NATTYPE_UNKNOWN;
mOldNatHole = RsNatHoleMode::UNKNOWN;
mOldNatType = RsNatTypeMode::UNKNOWN;
}
}

24
libretroshare/src/pqi/p3netmgr.h
View file

@ -103,11 +103,11 @@ virtual bool netAssistBadPeer(const struct sockaddr_storage &addr, uint32_t reas
virtual bool netAssistStatusUpdate(const RsPeerId &id, int mode) = 0;
/* Get Network State */
virtual uint32_t getNetStateMode() = 0;
virtual uint32_t getNetworkMode() = 0;
virtual uint32_t getNatTypeMode() = 0;
virtual uint32_t getNatHoleMode() = 0;
virtual uint32_t getConnectModes() = 0;
virtual RsNetState getNetStateMode() = 0;
virtual RsNetworkMode getNetworkMode() = 0;
virtual RsNatTypeMode getNatTypeMode() = 0;
virtual RsNatHoleMode getNatHoleMode() = 0;
virtual RsConnectModes getConnectModes() = 0;
/* Shut It Down! */
virtual bool shutdown() = 0; /* blocking shutdown call */
@ -154,11 +154,11 @@ virtual bool netAssistBadPeer(const struct sockaddr_storage &addr, uint32_t reas
virtual bool netAssistStatusUpdate(const RsPeerId &id, int mode);
/* Get Network State */
virtual uint32_t getNetStateMode();
virtual uint32_t getNetworkMode();
virtual uint32_t getNatTypeMode();
virtual uint32_t getNatHoleMode();
virtual uint32_t getConnectModes();
virtual RsNetState getNetStateMode();
virtual RsNetworkMode getNetworkMode();
virtual RsNatTypeMode getNatTypeMode();
virtual RsNatHoleMode getNatHoleMode();
virtual RsConnectModes getConnectModes();
/* Shut It Down! */
virtual bool shutdown(); /* blocking shutdown call */
@ -323,8 +323,8 @@ void netStatusReset_locked();
pqiNetStateBox mNetStateBox;
rstime_t mDoNotNetCheckUntilTs;
uint32_t mOldNatType;
uint32_t mOldNatHole;
RsNatTypeMode mOldNatType;
RsNatHoleMode mOldNatHole;
RS_SET_CONTEXT_DEBUG_LEVEL(2)
};

354
libretroshare/src/pqi/pqinetstatebox.cc
View file

@ -20,7 +20,6 @@
* *
*******************************************************************************/
#include "retroshare/rsconfig.h"
#include "util/rsnet.h"
#include "pqi/pqinetstatebox.h"
#include "util/rstime.h"
@ -147,32 +146,32 @@ void pqiNetStateBox::setDhtState(bool on, bool active)
/* Extract Net State */
uint32_t pqiNetStateBox::getNetworkMode()
RsNetworkMode pqiNetStateBox::getNetworkMode()
{
updateNetState();
return mNetworkMode;
}
uint32_t pqiNetStateBox::getNatTypeMode()
RsNatTypeMode pqiNetStateBox::getNatTypeMode()
{
updateNetState();
return mNatTypeMode;
}
uint32_t pqiNetStateBox::getNatHoleMode()
RsNatHoleMode pqiNetStateBox::getNatHoleMode()
{
updateNetState();
return mNatHoleMode;
}
uint32_t pqiNetStateBox::getConnectModes()
RsConnectModes pqiNetStateBox::getConnectModes()
{
updateNetState();
return mConnectModes;
}
uint32_t pqiNetStateBox::getNetStateMode()
RsNetState pqiNetStateBox::getNetStateMode()
{
updateNetState();
return mNetStateMode;
@ -193,11 +192,11 @@ void pqiNetStateBox::reset()
mStatusOkay = false;
//rstime_t mStatusTS;
mNetworkMode = RSNET_NETWORK_UNKNOWN;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_UNKNOWN;
mConnectModes = RSNET_CONNECT_NONE;
mNetStateMode = RSNET_NETSTATE_BAD_UNKNOWN;
mNetworkMode = RsNetworkMode::UNKNOWN;
mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::UNKNOWN;
mConnectModes = RsConnectModes::NONE;
mNetStateMode = RsNetState::BAD_UNKNOWN;
/* Parameters set externally */
@ -302,11 +301,11 @@ void pqiNetStateBox::determineNetworkState()
/* firstly lets try to identify OFFLINE / UNKNOWN */
if ((!mStunProxySet) || (!mStunDhtSet))
{
mNetworkMode = RSNET_NETWORK_UNKNOWN;
mNetworkMode = RsNetworkMode::UNKNOWN;
// Assume these.
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetStateMode = RSNET_NETSTATE_BAD_UNKNOWN;
mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::NONE;
mNetStateMode = RsNetState::BAD_UNKNOWN;
//mExtAddress = .... unknown;
//mExtAddrStable = false;
@ -335,19 +334,19 @@ void pqiNetStateBox::determineNetworkState()
*
*/
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_DETERM_SYM;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetStateMode = RSNET_NETSTATE_WARNING_NATTED;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::DETERM_SYM;
mNatHoleMode = RsNatHoleMode::NONE;
mNetStateMode = RsNetState::WARNING_NATTED;
}
else if (!mStunProxyStable)
{
/* both unstable, Symmetric NAT, Firewalled, No UDP Hole */
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_SYMMETRIC;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetStateMode = RSNET_NETSTATE_BAD_NATSYM;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::SYMMETRIC;
mNatHoleMode = RsNatHoleMode::NONE;
mNetStateMode = RsNetState::BAD_NATSYM;
}
else
{
@ -366,10 +365,10 @@ void pqiNetStateBox::determineNetworkState()
* but that label is really fully accurate. (gray area).
*/
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_RESTRICTED_CONE;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetStateMode = RSNET_NETSTATE_WARNING_NATTED;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::RESTRICTED_CONE;
mNatHoleMode = RsNatHoleMode::NONE;
mNetStateMode = RsNetState::WARNING_NATTED;
}
}
else // Dht Stable.
@ -392,47 +391,47 @@ void pqiNetStateBox::determineNetworkState()
if (mStunProxySemiStable)
{
/* must be a forwarded port/ext or something similar */
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_DETERM_SYM;
mNatHoleMode = RSNET_NATHOLE_FORWARDED;
mNetStateMode = RSNET_NETSTATE_GOOD;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::DETERM_SYM;
mNatHoleMode = RsNatHoleMode::FORWARDED;
mNetStateMode = RsNetState::GOOD;
}
else if (!mStunProxyStable)
{
/* must be a forwarded port/ext or something similar */
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_SYMMETRIC;
mNatHoleMode = RSNET_NATHOLE_FORWARDED;
mNetStateMode = RSNET_NETSTATE_GOOD;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::SYMMETRIC;
mNatHoleMode = RsNatHoleMode::FORWARDED;
mNetStateMode = RsNetState::GOOD;
}
else
{
/* fallback is FULL CONE NAT */
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_FULL_CONE;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetStateMode = RSNET_NETSTATE_WARNING_NATTED;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::FULL_CONE;
mNatHoleMode = RsNatHoleMode::NONE;
mNetStateMode = RsNetState::WARNING_NATTED;
}
if (mUPnPActive)
{
// This Mode is OKAY.
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNetworkMode = RsNetworkMode::BEHINDNAT;
// Use Fallback Guess.
//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_UPNP;
mNetStateMode = RSNET_NETSTATE_GOOD;
//mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::UPNP;
mNetStateMode = RsNetState::GOOD;
//mExtAddress = ... from UPnP, should match StunDht.
//mExtAddrStable = true;
}
else if (mNatPMPActive)
{
// This Mode is OKAY.
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNetworkMode = RsNetworkMode::BEHINDNAT;
// Use Fallback Guess.
//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_NATPMP;
mNetStateMode = RSNET_NETSTATE_GOOD;
//mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::NATPMP;
mNetStateMode = RsNetState::GOOD;
//mExtAddress = ... from NatPMP, should match NatPMP
//mExtAddrStable = true;
}
@ -442,20 +441,20 @@ void pqiNetStateBox::determineNetworkState()
if (isExtAddress)
{
mNetworkMode = RSNET_NETWORK_EXTERNALIP;
mNatTypeMode = RSNET_NATTYPE_NONE;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetStateMode = RSNET_NETSTATE_GOOD;
mNetworkMode = RsNetworkMode::EXTERNALIP;
mNatTypeMode = RsNatTypeMode::NONE;
mNatHoleMode = RsNatHoleMode::NONE;
mNetStateMode = RsNetState::GOOD;
//mExtAddrStable = true;
}
else if (mPortForwardSet)
{
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNetworkMode = RsNetworkMode::BEHINDNAT;
// Use Fallback Guess.
//mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_FORWARDED;
mNetStateMode = RSNET_NETSTATE_ADV_FORWARD;
//mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::FORWARDED;
mNetStateMode = RsNetState::ADV_FORWARD;
//mExtAddrStable = true; // Probably, makin assumption.
}
@ -479,22 +478,22 @@ void pqiNetStateBox::determineNetworkState()
if (mUPnPActive)
{
// This Mode is OKAY.
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_UPNP;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::UPNP;
//mExtAddress = ... from UPnP.
//mExtAddrStable = true;
mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
mNetStateMode = RsNetState::WARNING_NODHT;
}
else if (mNatPMPActive)
{
// This Mode is OKAY.
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_NATPMP;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::NATPMP;
//mExtAddress = ... from NatPMP.
//mExtAddrStable = true;
mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
mNetStateMode = RsNetState::WARNING_NODHT;
}
else
{
@ -506,21 +505,21 @@ void pqiNetStateBox::determineNetworkState()
if (isExtAddress)
{
mNetworkMode = RSNET_NETWORK_EXTERNALIP;
mNatTypeMode = RSNET_NATTYPE_NONE;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetworkMode = RsNetworkMode::EXTERNALIP;
mNatTypeMode = RsNatTypeMode::NONE;
mNatHoleMode = RsNatHoleMode::NONE;
//mExtAddrStable = true;
mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
mNetStateMode = RsNetState::WARNING_NODHT;
}
else if (mPortForwardSet)
{
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_FORWARDED;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::FORWARDED;
//mExtAddrStable = true; // Probably, makin assumption.
mNetStateMode = RSNET_NETSTATE_WARNING_NODHT;
mNetStateMode = RsNetState::WARNING_NODHT;
}
else
{
@ -528,10 +527,10 @@ void pqiNetStateBox::determineNetworkState()
* These people have destroyed the possibility of making connections ;(
* Should WARN about this.
*/
mNetworkMode = RSNET_NETWORK_BEHINDNAT;
mNatTypeMode = RSNET_NATTYPE_UNKNOWN;
mNatHoleMode = RSNET_NATHOLE_NONE;
mNetStateMode = RSNET_NETSTATE_BAD_NODHT_NAT;
mNetworkMode = RsNetworkMode::BEHINDNAT;
mNatTypeMode = RsNatTypeMode::UNKNOWN;
mNatHoleMode = RsNatHoleMode::NONE;
mNetStateMode = RsNetState::BAD_NODHT_NAT;
//mExtAddrStable = false; // Unlikely to be stable.
}
@ -553,42 +552,43 @@ void pqiNetStateBox::determineNetworkState()
void pqiNetStateBox::workoutNetworkMode()
{
/* connectModes are dependent on the other modes */
mConnectModes = RSNET_CONNECT_NONE;
mConnectModes = RsConnectModes::NONE;
switch(mNetworkMode)
{
case RSNET_NETWORK_UNKNOWN:
case RSNET_NETWORK_OFFLINE:
case RSNET_NETWORK_LOCALNET:
case RsNetworkMode::UNKNOWN:
case RsNetworkMode::OFFLINE:
case RsNetworkMode::LOCALNET:
case RsNetworkMode::RESTARTING:
/* nothing here */
break;
case RSNET_NETWORK_EXTERNALIP:
mConnectModes = RSNET_CONNECT_OUTGOING_TCP;
mConnectModes |= RSNET_CONNECT_ACCEPT_TCP;
case RsNetworkMode::EXTERNALIP:
mConnectModes = RsConnectModes::OUTGOING_TCP;
mConnectModes |= RsConnectModes::ACCEPT_TCP;
if (mDhtActive)
{
mConnectModes |= RSNET_CONNECT_DIRECT_UDP;
mConnectModes |= RsConnectModes::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 |= RSNET_CONNECT_PROXY_UDP;
//mConnectModes |= RSNET_CONNECT_RELAY_UDP;
//mConnectModes |= RsConnectModes::PROXY_UDP;
//mConnectModes |= RsConnectModes::RELAY_UDP;
}
break;
case RSNET_NETWORK_BEHINDNAT:
mConnectModes = RSNET_CONNECT_OUTGOING_TCP;
case RsNetworkMode::BEHINDNAT:
mConnectModes = RsConnectModes::OUTGOING_TCP;
/* we're okay if there's a NAT HOLE */
if ((mNatHoleMode == RSNET_NATHOLE_UPNP) ||
(mNatHoleMode == RSNET_NATHOLE_NATPMP) ||
(mNatHoleMode == RSNET_NATHOLE_FORWARDED))
if ((mNatHoleMode == RsNatHoleMode::UPNP) ||
(mNatHoleMode == RsNatHoleMode::NATPMP) ||
(mNatHoleMode == RsNatHoleMode::FORWARDED))
{
mConnectModes |= RSNET_CONNECT_ACCEPT_TCP;
mConnectModes |= RsConnectModes::ACCEPT_TCP;
if (mDhtActive)
{
mConnectModes |= RSNET_CONNECT_DIRECT_UDP;
mConnectModes |= RsConnectModes::DIRECT_UDP;
/* dont want PROXY | RELAY with open ports */
}
}
@ -600,175 +600,17 @@ void pqiNetStateBox::workoutNetworkMode()
*/
if (mDhtActive)
{
mConnectModes |= RSNET_CONNECT_DIRECT_UDP;
mConnectModes |= RSNET_CONNECT_RELAY_UDP;
mConnectModes |= RsConnectModes::DIRECT_UDP;
mConnectModes |= RsConnectModes::RELAY_UDP;
if ((mNatTypeMode == RSNET_NATTYPE_RESTRICTED_CONE) ||
(mNatTypeMode == RSNET_NATTYPE_FULL_CONE) ||
(mNatTypeMode == RSNET_NATTYPE_DETERM_SYM))
if ((mNatTypeMode == RsNatTypeMode::RESTRICTED_CONE) ||
(mNatTypeMode == RsNatTypeMode::FULL_CONE) ||
(mNatTypeMode == RsNatTypeMode::DETERM_SYM))
{
mConnectModes |= RSNET_CONNECT_PROXY_UDP;
mConnectModes |= RsConnectModes::PROXY_UDP;
}
}
}
break;
}
}
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_DETERM_SYM:
str = "DETERMINISTIC SYM 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::string 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;
}
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;
}

32
libretroshare/src/pqi/pqinetstatebox.h
View file

@ -27,6 +27,9 @@
#include <string>
#include <list>
#include <util/rstime.h>
#include <retroshare/rsconfig.h>
/*** Network state
* Want this to be all encompassing.
*
@ -51,11 +54,11 @@ class pqiNetStateBox
void setDhtState(bool dhtOn, bool dhtActive);
uint32_t getNetStateMode();
uint32_t getNetworkMode();
uint32_t getNatTypeMode();
uint32_t getNatHoleMode();
uint32_t getConnectModes();
RsNetState getNetStateMode();
RsNetworkMode getNetworkMode();
RsNatTypeMode getNatTypeMode();
RsNatHoleMode getNatHoleMode();
RsConnectModes getConnectModes();
private:
@ -71,11 +74,11 @@ class pqiNetStateBox
bool mStatusOkay;
rstime_t mStatusTS;
uint32_t mNetworkMode;
uint32_t mNatTypeMode;
uint32_t mNatHoleMode;
uint32_t mConnectModes;
uint32_t mNetStateMode;
RsNetworkMode mNetworkMode;
RsNatTypeMode mNatTypeMode;
RsNatHoleMode mNatHoleMode;
RsConnectModes mConnectModes;
RsNetState mNetStateMode;
/* Parameters set externally */
@ -114,13 +117,4 @@ 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

150
libretroshare/src/retroshare/rsconfig.h
View file

@ -37,77 +37,82 @@ class RsServerConfig;
*/
extern RsServerConfig *rsConfig;
#define RSNET_NETWORK_UNKNOWN 1
#define RSNET_NETWORK_RESTARTING 2
#define RSNET_NETWORK_OFFLINE 3
#define RSNET_NETWORK_LOCALNET 4
#define RSNET_NETWORK_BEHINDNAT 5
#define RSNET_NETWORK_EXTERNALIP 6
enum class RsNetworkMode : uint8_t
{
UNKNOWN = 1,
RESTARTING = 2,
OFFLINE = 3,
LOCALNET = 4,
BEHINDNAT = 5,
EXTERNALIP = 6
};
// WHAT TYPE OF FIREWALL?
#define RSNET_NATTYPE_NONE 1
#define RSNET_NATTYPE_UNKNOWN 2
#define RSNET_NATTYPE_SYMMETRIC 3
#define RSNET_NATTYPE_DETERM_SYM 4
#define RSNET_NATTYPE_RESTRICTED_CONE 5
#define RSNET_NATTYPE_FULL_CONE 6
#define RSNET_NATTYPE_OTHER 7
enum class RsNatTypeMode : uint8_t
{
NONE = 1,
UNKNOWN = 2,
SYMMETRIC = 3,
DETERM_SYM = 4,
RESTRICTED_CONE = 5,
FULL_CONE = 6,
OTHER = 7
};
// WHAT TYPE OF HOLE?
#define RSNET_NATHOLE_UNKNOWN 0
#define RSNET_NATHOLE_NONE 1
#define RSNET_NATHOLE_UPNP 2
#define RSNET_NATHOLE_NATPMP 3
#define RSNET_NATHOLE_FORWARDED 4
enum class RsNatHoleMode : uint8_t
{
UNKNOWN = 0,
NONE = 1,
UPNP = 2,
NATPMP = 3,
FORWARDED = 4
};
// Types of Connections.
#define RSNET_CONNECT_NONE 0x0000
#define RSNET_CONNECT_ACCEPT_TCP 0x0001
#define RSNET_CONNECT_OUTGOING_TCP 0x0002
#define RSNET_CONNECT_DIRECT_UDP 0x0100
#define RSNET_CONNECT_PROXY_UDP 0x0200
#define RSNET_CONNECT_RELAY_UDP 0x0400
enum class RsConnectModes : uint16_t
{
NONE = 0x0000,
ACCEPT_TCP = 0x0001,
OUTGOING_TCP= 0x0002,
DIRECT_UDP = 0x0100,
PROXY_UDP = 0x0200,
RELAY_UDP = 0x0400
};
RS_REGISTER_ENUM_FLAGS_TYPE(RsConnectModes)
// net state (good, okay, bad)
// BAD. (RED)
#define RSNET_NETSTATE_BAD_UNKNOWN 1
#define RSNET_NETSTATE_BAD_OFFLINE 2
#define RSNET_NETSTATE_BAD_NATSYM 3
#define RSNET_NETSTATE_BAD_NODHT_NAT 4
enum class RsNetState : uint8_t
{
// BAD. (RED)
BAD_UNKNOWN = 1,
BAD_OFFLINE = 2,
BAD_NATSYM = 3,
BAD_NODHT_NAT = 4,
// CAUTION. (ORANGE)
#define RSNET_NETSTATE_WARNING_RESTART 5
#define RSNET_NETSTATE_WARNING_NATTED 6
#define RSNET_NETSTATE_WARNING_NODHT 7
// CAUTION. (ORANGE)
WARNING_RESTART = 5,
WARNING_NATTED = 6,
WARNING_NODHT = 7,
// GOOD (GREEN)
// NAT with forwarded port, or EXT port.
#define RSNET_NETSTATE_GOOD 8
// ADVANCED MODE (BLUE)
// If the user knows what they are doing... we cannot confirm this.
#define RSNET_NETSTATE_ADV_FORWARD 9
#define RSNET_NETSTATE_ADV_DARK_FORWARD 10
/* matched to the uPnP states */
#define UPNP_STATE_UNINITIALISED 0
#define UPNP_STATE_UNAVAILABILE 1
#define UPNP_STATE_READY 2
#define UPNP_STATE_FAILED_TCP 3
#define UPNP_STATE_FAILED_UDP 4
#define UPNP_STATE_ACTIVE 5
// GOOD (GREEN)
// NAT with forwarded port, or EXT port.
GOOD = 8,
// ADVANCED MODE (BLUE)
// If the user knows what they are doing... we cannot confirm this.
ADV_FORWARD = 9,
ADV_DARK_FORWARD= 10
};
/************************** Indicate How experienced the RsUser is... based on Friends / Firewall status ******/
#define RSCONFIG_USER_LEVEL_NEW 0x0001 /* no friends */
#define RSCONFIG_USER_LEVEL_BASIC 0x0002 /* no connections */
#define RSCONFIG_USER_LEVEL_CASUAL 0x0003 /* firewalled */
#define RSCONFIG_USER_LEVEL_POWER 0x0004 /* good! */
#define RSCONFIG_USER_LEVEL_OVERRIDE 0x0005 /* forced to POWER level */
enum class RsConfigUserLvl : uint8_t
{
NEW = 1, /* no friends */
BASIC = 2, /* no connections */
CASUAL = 3, /* firewalled */
POWER = 4, /* good! */
OVERRIDE= 5 /* forced to POWER level */
};
@ -115,10 +120,13 @@ extern RsServerConfig *rsConfig;
#define RS_CONFIG_ADVANCED 0x0101
#define RS_OPMODE_FULL 0x0001
#define RS_OPMODE_NOTURTLE 0x0002
#define RS_OPMODE_GAMING 0x0003
#define RS_OPMODE_MINIMAL 0x0004
enum class RsOpMode : uint8_t
{
FULL = 1,
NOTURTLE= 2,
GAMING = 3,
MINIMAL = 4
};
class RsConfigStartup
@ -348,13 +356,13 @@ public:
/* New Stuff */
virtual uint32_t getUserLevel() = 0;
virtual RsConfigUserLvl getUserLevel() = 0;
virtual uint32_t getNetState() = 0;
virtual uint32_t getNetworkMode() = 0;
virtual uint32_t getNatTypeMode() = 0;
virtual uint32_t getNatHoleMode() = 0;
virtual uint32_t getConnectModes() = 0;
virtual RsNetState getNetState() = 0;
virtual RsNetworkMode getNetworkMode() = 0;
virtual RsNatTypeMode getNatTypeMode() = 0;
virtual RsNatHoleMode getNatHoleMode() = 0;
virtual RsConnectModes getConnectModes() = 0;
virtual bool getConfigurationOption(uint32_t key, std::string &opt) = 0;
virtual bool setConfigurationOption(uint32_t key, const std::string &opt) = 0;
@ -366,7 +374,7 @@ public:
* @jsonapi{development}
* @return return the current operating mode
*/
virtual uint32_t getOperatingMode() = 0;
virtual RsOpMode getOperatingMode() = 0;
/**
* @brief setOperatingMode set the current oprating mode
@ -374,7 +382,7 @@ public:
* @param[in] opMode new opearting mode
* @return
*/
virtual bool setOperatingMode(uint32_t opMode) = 0;
virtual bool setOperatingMode(RsOpMode opMode) = 0;
/**
* @brief setOperatingMode set the current operating mode from string

112
libretroshare/src/retroshare/rsdht.h
View file

@ -27,6 +27,7 @@
#include <list>
#include <retroshare/rstypes.h>
#include "util/rsnet.h"
#include "retroshare/rsflags.h"
/* The Main Interface Class - for information about your Peers */
class RsDht;
@ -35,55 +36,66 @@ extern RsDht *rsDht;
//std::ostream &operator<<(std::ostream &out, const RsPhotoShowDetails &detail);
//std::ostream &operator<<(std::ostream &out, const RsPhotoDetails &detail);
#define RSDHT_NETSTART_NETWORKMODE 0x0001
#define RSDHT_NETSTART_NATTYPE 0x0002
#define RSDHT_NETSTART_NATHOLE 0x0003
#define RSDHT_NETSTART_CONNECTMODES 0x0004
#define RSDHT_NETSTART_NETSTATE 0x0005
enum class RsDhtPeerType : uint8_t
{
ANY = 0,
OTHER = 1,
FOF = 2,
FRIEND = 3
};
enum class RsDhtPeerDht : uint8_t
{
NOT_ACTIVE = 0,
SEARCHING = 1,
FAILURE = 2,
OFFLINE = 3,
UNREACHABLE = 4,
ONLINE = 5
};
enum class RsDhtPeerConnectState : uint8_t
{
DISCONNECTED = 1,
UDP_STARTED = 2,
CONNECTED = 3
};
#define RSDHT_PEERTYPE_ANY 0x0000
#define RSDHT_PEERTYPE_OTHER 0x0001
#define RSDHT_PEERTYPE_FOF 0x0002
#define RSDHT_PEERTYPE_FRIEND 0x0003
enum class RsDhtPeerRequest : uint8_t
{
STOPPED = 1,
RUNNING = 2
};
#define RSDHT_PEERDHT_NOT_ACTIVE 0x0000
#define RSDHT_PEERDHT_SEARCHING 0x0001
#define RSDHT_PEERDHT_FAILURE 0x0002
#define RSDHT_PEERDHT_OFFLINE 0x0003
#define RSDHT_PEERDHT_UNREACHABLE 0x0004
#define RSDHT_PEERDHT_ONLINE 0x0005
enum class RsDhtTouMode : uint8_t
{
NONE = 0,
DIRECT = 1,
PROXY = 2,
RELAY = 3
};
#define RSDHT_PEERCONN_DISCONNECTED 1
#define RSDHT_PEERCONN_UDP_STARTED 2
#define RSDHT_PEERCONN_CONNECTED 3
enum class RsDhtRelayClass : uint8_t
{
ALL = 0,
GENERAL = 1,
FOF = 2,
FRIENDS = 3,
#define RSDHT_PEERREQ_STOPPED 1
#define RSDHT_PEERREQ_RUNNING 2
NUM_CLASS = 4
};
#define RSDHT_TOU_MODE_NONE 0
#define RSDHT_TOU_MODE_DIRECT 1
#define RSDHT_TOU_MODE_PROXY 2
#define RSDHT_TOU_MODE_RELAY 3
#define RSDHT_RELAY_NUM_CLASS 4
#define RSDHT_RELAY_CLASS_ALL 0
#define RSDHT_RELAY_CLASS_GENERAL 1
#define RSDHT_RELAY_CLASS_FOF 2
#define RSDHT_RELAY_CLASS_FRIENDS 3
#define RSDHT_RELAY_MODE_MASK 0x00f0
#define RSDHT_RELAY_ENABLED 0x0001
#define RSDHT_RELAY_MODE_OFF 0x0010
#define RSDHT_RELAY_MODE_ON 0x0020
#define RSDHT_RELAY_MODE_SERVER 0x0040
enum class RsDhtRelayMode : uint16_t
{
DISABLED= 0x0000,
ENABLED = 0x0001,
MASK = 0x00f0,
OFF = 0x0010,
ON = 0x0020,
SERVER = 0x0040
};
RS_REGISTER_ENUM_FLAGS_TYPE(RsDhtRelayMode)
class RsDhtPeer
{
@ -108,18 +120,18 @@ class RsDhtNetPeer
std::string mDhtId;
RsPeerId mRsId;
uint32_t mPeerType;
uint32_t mDhtState;
RsDhtPeerType mPeerType;
RsDhtPeerDht mDhtState;
std::string mConnectState; // connectLogic.
uint32_t mPeerConnectState; // connect Status
uint32_t mPeerConnectMode; // connect mode
RsDhtPeerConnectState mPeerConnectState;
RsDhtTouMode mPeerConnectMode;
bool mExclusiveProxyLock;
std::string mPeerConnectProxyId;
uint32_t mPeerReqState; // Req Status.
RsDhtPeerRequest mPeerReqState;
std::string mCbPeerMsg; // Peer Cb Mgs.
};
@ -188,11 +200,11 @@ virtual int getRelayServerList(std::list<std::string> &ids) = 0;
virtual int addRelayServer(std::string ids) = 0;
virtual int removeRelayServer(std::string ids) = 0;
virtual uint32_t getRelayMode() = 0;
virtual int setRelayMode(uint32_t mode) = 0;
virtual RsDhtRelayMode getRelayMode() = 0;
virtual int setRelayMode(RsDhtRelayMode mode) = 0;
virtual int getRelayAllowance(int classIdx, uint32_t &count, uint32_t &bandwidth) = 0;
virtual int setRelayAllowance(int classIdx, uint32_t count, uint32_t bandwidth) = 0;
virtual int getRelayAllowance(RsDhtRelayClass classIdx, uint32_t &count, uint32_t &bandwidth) = 0;
virtual int setRelayAllowance(RsDhtRelayClass classIdx, uint32_t count, uint32_t bandwidth) = 0;
// So we can provide to clients.
virtual bool getOwnDhtId(std::string &ownDhtId) = 0;

9
libretroshare/src/retroshare/rsflags.h
View file

@ -37,7 +37,13 @@ using rs_is_scoped_enum = std::integral_constant< bool,
* it as flags type passing it as parameter of this macro.
* The result will be type safe flags, that cannot be mixed up with flag of a
* different type, but that are very comfortable to operate like plain old
* integers.
* integers. All commom operation like &, | or ! can be used. To convert
* the result of such operation to boolean use !!:
@code{.cpp}
RsConnectModes connect = rsConfig->getConnectModes();
if (!!(connect & RsConnectModes::OUTGOING_TCP))
@endcode
*
* This macro support flag fields of different lenght depending on what
* underlining type (usually from uint8_t up to uint64_t) has been declared for
* the enum class.
@ -45,6 +51,7 @@ using rs_is_scoped_enum = std::integral_constant< bool,
* underlining type of the enum otherwise different compilers may serialize a
* flag variable with different lenght, potentially causing interoperability
* issues between differents builds.
*
* Usage example:
@code{.cpp}
enum class RsGrouterItemFlags : uint32_t

2
libretroshare/src/retroshare/rsgxsforums.h
View file

@ -38,7 +38,7 @@
class RsGxsForums;
/**
* Pointer to global instance of RsGxsChannels service implementation
* Pointer to global instance of RsGxsForums service implementation
* @jsonapi{development}
*/
extern RsGxsForums* rsGxsForums;

94
libretroshare/src/rsserver/p3serverconfig.cc
View file

@ -48,11 +48,11 @@ p3ServerConfig::p3ServerConfig(p3PeerMgr *peerMgr, p3LinkMgr *linkMgr, p3NetMgr
RsStackMutex stack(configMtx); /******* LOCKED MUTEX *****/
mUserLevel = RSCONFIG_USER_LEVEL_NEW; /* START LEVEL */
mUserLevel = RsConfigUserLvl::NEW; /* START LEVEL */
mRateDownload = DEFAULT_DOWNLOAD_KB_RATE;
mRateUpload = DEFAULT_UPLOAD_KB_RATE;
mOpMode = RS_OPMODE_FULL;
mOpMode = RsOpMode::FULL;
rsConfig = this;
}
@ -86,7 +86,7 @@ void p3ServerConfig::load_config()
}
/* enable operating mode */
uint32_t opMode = getOperatingMode();
RsOpMode opMode = getOperatingMode();
switchToOperatingMode(opMode);
}
@ -264,9 +264,9 @@ std::string p3ServerConfig::getRetroshareDataDirectory()
/* New Stuff */
uint32_t p3ServerConfig::getUserLevel()
RsConfigUserLvl p3ServerConfig::getUserLevel()
{
uint32_t userLevel = RSCONFIG_USER_LEVEL_NEW;
RsConfigUserLvl userLevel = RsConfigUserLvl::NEW;
{
RsStackMutex stack(configMtx); /******* LOCKED MUTEX *****/
userLevel = mUserLevel;
@ -274,47 +274,47 @@ uint32_t p3ServerConfig::getUserLevel()
switch(userLevel)
{
case RSCONFIG_USER_LEVEL_OVERRIDE:
case RsConfigUserLvl::OVERRIDE:
break;
#define MIN_BASIC_FRIENDS 2
// FALL THROUGH EVERYTHING.
default:
case RSCONFIG_USER_LEVEL_NEW:
case RsConfigUserLvl::NEW:
{
if (mPeerMgr->getFriendCount(true, false) > MIN_BASIC_FRIENDS)
{
userLevel = RSCONFIG_USER_LEVEL_BASIC;
userLevel = RsConfigUserLvl::BASIC;
}
}
/* fallthrough */
case RSCONFIG_USER_LEVEL_BASIC:
case RsConfigUserLvl::BASIC:
{
/* check that we have some lastConnect > 0 */
if (mPeerMgr->haveOnceConnected())
{
userLevel = RSCONFIG_USER_LEVEL_CASUAL;
userLevel = RsConfigUserLvl::CASUAL;
}
}
/* fallthrough */
case RSCONFIG_USER_LEVEL_CASUAL:
case RSCONFIG_USER_LEVEL_POWER:
case RsConfigUserLvl::CASUAL:
case RsConfigUserLvl::POWER:
{
/* check that the firewall is open */
uint32_t netMode = mNetMgr->getNetworkMode();
uint32_t firewallMode = mNetMgr->getNatHoleMode();
RsNetworkMode netMode = mNetMgr->getNetworkMode();
RsNatHoleMode firewallMode = mNetMgr->getNatHoleMode();
if ((RSNET_NETWORK_EXTERNALIP == netMode) ||
((RSNET_NETWORK_BEHINDNAT == netMode) &&
((RSNET_NATHOLE_UPNP == firewallMode) ||
(RSNET_NATHOLE_NATPMP == firewallMode) ||
(RSNET_NATHOLE_FORWARDED == firewallMode))))
if ((RsNetworkMode::EXTERNALIP == netMode) ||
((RsNetworkMode::BEHINDNAT == netMode) &&
(RsNatHoleMode::UPNP == firewallMode ||
(RsNatHoleMode::NATPMP == firewallMode) ||
(RsNatHoleMode::FORWARDED == firewallMode))))
{
userLevel = RSCONFIG_USER_LEVEL_POWER;
userLevel = RsConfigUserLvl::POWER;
}
}
break; /* for all */
@ -329,27 +329,27 @@ uint32_t p3ServerConfig::getUserLevel()
}
uint32_t p3ServerConfig::getNetState()
RsNetState p3ServerConfig::getNetState()
{
return mNetMgr->getNetStateMode();
}
uint32_t p3ServerConfig::getNetworkMode()
RsNetworkMode p3ServerConfig::getNetworkMode()
{
return mNetMgr->getNetworkMode();
}
uint32_t p3ServerConfig::getNatTypeMode()
RsNatTypeMode p3ServerConfig::getNatTypeMode()
{
return mNetMgr->getNatTypeMode();
}
uint32_t p3ServerConfig::getNatHoleMode()
RsNatHoleMode p3ServerConfig::getNatHoleMode()
{
return mNetMgr->getNatHoleMode();
}
uint32_t p3ServerConfig::getConnectModes()
RsConnectModes p3ServerConfig::getConnectModes()
{
return mNetMgr->getConnectModes();
}
@ -357,27 +357,27 @@ uint32_t p3ServerConfig::getConnectModes()
/* Operating Mode */
#define RS_CONFIG_OPERATING_STRING "OperatingMode"
uint32_t p3ServerConfig::getOperatingMode()
RsOpMode p3ServerConfig::getOperatingMode()
{
#ifdef SAVE_OPERATING_MODE
std::string modestr = mGeneralConfig->getSetting(RS_CONFIG_OPERATING_STRING);
uint32_t mode = RS_OPMODE_FULL;
uint32_t mode = RsOpMode::FULL;
if (modestr == "FULL")
{
mode = RS_OPMODE_FULL;
mode = RsOpMode::FULL;
}
else if (modestr == "NOTURTLE")
{
mode = RS_OPMODE_NOTURTLE;
mode = RsOpMode::NOTURTLE;
}
else if (modestr == "GAMING")
{
mode = RS_OPMODE_GAMING;
mode = RsOpMode::GAMING;
}
else if (modestr == "MINIMAL")
{
mode = RS_OPMODE_MINIMAL;
mode = RsOpMode::MINIMAL;
}
return mode;
#else
@ -387,24 +387,24 @@ uint32_t p3ServerConfig::getOperatingMode()
}
bool p3ServerConfig::setOperatingMode(uint32_t opMode)
bool p3ServerConfig::setOperatingMode(RsOpMode opMode)
{
#ifdef SAVE_OPERATING_MODE
std::string modestr = "FULL";
switch(opMode)
{
case RS_OPMODE_FULL:
case RsOpMode::FULL:
modestr = "FULL";
break;
case RS_OPMODE_NOTURTLE:
case RsOpMode::NOTURTLE:
modestr = "NOTURTLE";
break;
case RS_OPMODE_GAMING:
case RsOpMode::GAMING:
modestr = "GAMING";
break;
case RS_OPMODE_MINIMAL:
case RsOpMode::MINIMAL:
modestr = "MINIMAL";
break;
}
@ -420,31 +420,31 @@ bool p3ServerConfig::setOperatingMode(uint32_t opMode)
bool p3ServerConfig::setOperatingMode(const std::string &opModeStr)
{
uint32_t opMode = RS_OPMODE_FULL;
RsOpMode opMode = RsOpMode::FULL;
std::string upper;
stringToUpperCase(opModeStr, upper);
if (upper == "NOTURTLE")
{
opMode = RS_OPMODE_NOTURTLE;
opMode = RsOpMode::NOTURTLE;
}
else if (upper == "GAMING")
{
opMode = RS_OPMODE_GAMING;
opMode = RsOpMode::GAMING;
}
else if (upper == "MINIMAL")
{
opMode = RS_OPMODE_MINIMAL;
opMode = RsOpMode::MINIMAL;
}
else // "FULL" by default
{
opMode = RS_OPMODE_FULL;
opMode = RsOpMode::FULL;
}
return setOperatingMode(opMode);
}
bool p3ServerConfig::switchToOperatingMode(uint32_t opMode)
bool p3ServerConfig::switchToOperatingMode(RsOpMode opMode)
{
float dl_rate = 0;
float ul_rate = 0;
@ -456,13 +456,13 @@ bool p3ServerConfig::switchToOperatingMode(uint32_t opMode)
ul_rate = mRateUpload;
}
std::cerr << "p3ServerConfig::switchToOperatingMode(" << opMode << ")";
std::cerr << "p3ServerConfig::switchToOperatingMode(" << static_cast<typename std::underlying_type<RsOpMode>::type>(opMode) << ")";
std::cerr << std::endl;
switch (opMode)
{
default:
case RS_OPMODE_FULL:
case RsOpMode::FULL:
/* switch on all transfers */
/* 100% bandwidth */
/* switch on popups, enable hashing */
@ -470,14 +470,14 @@ bool p3ServerConfig::switchToOperatingMode(uint32_t opMode)
//setMaxRate(false, mro); // Out / Upload.
turtle_enabled = true;
break;
case RS_OPMODE_NOTURTLE:
case RsOpMode::NOTURTLE:
/* switch on all transfers - except turtle, enable hashing */
/* 100% bandwidth */
/* switch on popups, enable hashing */
turtle_enabled = false;
break;
case RS_OPMODE_GAMING:
case RsOpMode::GAMING:
/* switch on all transfers */
/* reduce bandwidth to 25% */
/* switch off popups, enable hashing */
@ -486,7 +486,7 @@ bool p3ServerConfig::switchToOperatingMode(uint32_t opMode)
dl_rate *= 0.25;
ul_rate *= 0.25;
break;
case RS_OPMODE_MINIMAL:
case RsOpMode::MINIMAL:
/* switch off all transfers */
/* reduce bandwidth to 10%, but make sure there is enough for VoIP */
/* switch on popups, enable hashing */

22
libretroshare/src/rsserver/p3serverconfig.h
View file

@ -72,20 +72,20 @@ virtual std::string getRetroshareDataDirectory();
/* New Stuff */
virtual uint32_t getUserLevel();
virtual RsConfigUserLvl getUserLevel();
virtual uint32_t getNetState();
virtual uint32_t getNetworkMode();
virtual uint32_t getNatTypeMode();
virtual uint32_t getNatHoleMode();
virtual uint32_t getConnectModes();
virtual RsNetState getNetState();
virtual RsNetworkMode getNetworkMode();
virtual RsNatTypeMode getNatTypeMode();
virtual RsNatHoleMode getNatHoleMode();
virtual RsConnectModes getConnectModes();
virtual bool getConfigurationOption(uint32_t key, std::string &opt);
virtual bool setConfigurationOption(uint32_t key, const std::string &opt);
/* Operating Mode */
virtual uint32_t getOperatingMode();
virtual bool setOperatingMode(uint32_t opMode);
virtual RsOpMode getOperatingMode();
virtual bool setOperatingMode(RsOpMode opMode);
virtual bool setOperatingMode(const std::string &opModeStr);
virtual int SetMaxDataRates( int downKb, int upKb );
@ -97,7 +97,7 @@ virtual int GetTrafficSum( uint64_t &inb, uint64_t &outb );
private:
bool switchToOperatingMode(uint32_t opMode);
bool switchToOperatingMode(RsOpMode opMode);
bool findConfigurationOption(uint32_t key, std::string &keystr);
@ -108,11 +108,11 @@ bool findConfigurationOption(uint32_t key, std::string &keystr);
p3GeneralConfig *mGeneralConfig;
RsMutex configMtx;
uint32_t mUserLevel; // store last one... will later be a config Item too.
RsConfigUserLvl mUserLevel; // store last one... will later be a config Item too.
float mRateDownload;
float mRateUpload;
uint32_t mOpMode;
RsOpMode mOpMode;
};
#endif

12
libretroshare/src/tcponudp/udprelay.cc
View file

@ -298,13 +298,13 @@ int UdpRelayReceiver::checkRelays()
switch(rit->second.mRelayClass)
{
default:
case UDP_RELAY_CLASS_GENERAL:
case UDP_RELAY_CLASS_GENERAL:
lifetime = UDP_RELAY_LIFETIME_GENERAL;
break;
case UDP_RELAY_CLASS_FOF:
case UDP_RELAY_CLASS_FOF:
lifetime = UDP_RELAY_LIFETIME_FOF;
break;
case UDP_RELAY_CLASS_FRIENDS:
case UDP_RELAY_CLASS_FRIENDS:
lifetime = UDP_RELAY_LIFETIME_FRIENDS;
break;
}
@ -1048,13 +1048,13 @@ UdpRelayProxy::UdpRelayProxy(UdpRelayAddrSet *addrSet, int relayClass, uint32_t
switch(relayClass)
{
default:
case UDP_RELAY_CLASS_GENERAL:
case UDP_RELAY_CLASS_GENERAL:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
case UDP_RELAY_CLASS_FOF:
case UDP_RELAY_CLASS_FOF:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
case UDP_RELAY_CLASS_FRIENDS:
case UDP_RELAY_CLASS_FRIENDS:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
}

12
libretroshare/src/tcponudp/udprelay.h
View file

@ -101,12 +101,14 @@ std::ostream &operator<<(std::ostream &out, const UdpRelayEnd &ure);
/**** DEFINED IN EXTERNAL HEADER FILE ***/
#define UDP_RELAY_NUM_CLASS RSDHT_RELAY_NUM_CLASS
// sehraf: this is a bit ugly but since the int is used as an integer i'lll stick to this hack for now
/// TODO fix me!
#define UDP_RELAY_NUM_CLASS static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::NUM_CLASS)
#define UDP_RELAY_CLASS_ALL RSDHT_RELAY_CLASS_ALL
#define UDP_RELAY_CLASS_GENERAL RSDHT_RELAY_CLASS_GENERAL
#define UDP_RELAY_CLASS_FOF RSDHT_RELAY_CLASS_FOF
#define UDP_RELAY_CLASS_FRIENDS RSDHT_RELAY_CLASS_FRIENDS
#define UDP_RELAY_CLASS_ALL static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::ALL)
#define UDP_RELAY_CLASS_GENERAL static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::GENERAL)
#define UDP_RELAY_CLASS_FOF static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::FOF)
#define UDP_RELAY_CLASS_FRIENDS static_cast<typename std::underlying_type<RsDhtRelayClass>::type>(RsDhtRelayClass::FRIENDS)
// Just for some testing fun!
//#define UDP_RELAY_LIFETIME_GENERAL 180 // 3 minutes