Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-10-01 02:35:48 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity
6de5024634
RetroShare/libretroshare/src/pqi/p3connmgr.cc
csoler a293a39d1b - Integrated the turtle search and download to the gui. Now the search handles both friend and turtle searching. 
- added a console in config->server->F2F routing to be able to visualize turtle routing statistics

WARNING: this is not complete yet. The fllowing still needs to be done:
- detect duplicates in search results between turtle and friends search
- RegExpr search does ot work with turtle (still to code).
- search does not search own files. Is this really needed after all ?



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@1540 b45a01b8-16f6-495d-af2f-9b41ad6348cc
2009-08-16 20:10:53 +00:00

3545 lines
82 KiB
C++
Raw Blame History

/*
* libretroshare/src/pqi: p3connmgr.cc
*
* 3P/PQI network interface for RetroShare.
*
* Copyright 2007-2008 by Robert Fernie.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License Version 2 as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
* Please report all bugs and problems to "retroshare@lunamutt.com".
*
*/
#include "pqi/p3connmgr.h"
#include "pqi/p3dhtmgr.h" // Only need it for constants.
#include "tcponudp/tou.h"
#include "tcponudp/extaddrfinder.h"
#include "util/rsprint.h"
#include "util/rsdebug.h"
const int p3connectzone = 3431;
#include "serialiser/rsconfigitems.h"
#include "pqi/pqinotify.h"
#include <sstream>
/* Network setup States */
const uint32_t RS_NET_UNKNOWN = 0x0001;
const uint32_t RS_NET_UPNP_INIT = 0x0002;
const uint32_t RS_NET_UPNP_SETUP = 0x0003;
const uint32_t RS_NET_UDP_SETUP = 0x0004;
const uint32_t RS_NET_DONE = 0x0005;
/* Stun modes (TODO) */
const uint32_t RS_STUN_DHT = 0x0001;
const uint32_t RS_STUN_DONE = 0x0002;
const uint32_t RS_STUN_LIST_MIN = 100;
const uint32_t RS_STUN_FOUND_MIN = 10;
const uint32_t MAX_UPNP_INIT = 10; /* seconds UPnP timeout */
/****
* #define CONN_DEBUG 1
***/
/****
* #define P3CONNMGR_NO_TCP_CONNECTIONS 1
***/
/****
* #define P3CONNMGR_NO_AUTO_CONNECTION 1
***/
const uint32_t P3CONNMGR_TCP_DEFAULT_DELAY = 2; /* 2 Seconds? is it be enough! */
const uint32_t P3CONNMGR_UDP_DHT_DELAY = DHT_NOTIFY_PERIOD + 60; /* + 1 minute for DHT POST */
const uint32_t P3CONNMGR_UDP_PROXY_DELAY = 30; /* 30 seconds (NOT IMPLEMENTED YET!) */
#define MAX_AVAIL_PERIOD (2 * DHT_NOTIFY_PERIOD) // If we haven't connected in 2 DHT periods.
#define MIN_RETRY_PERIOD (DHT_CHECK_PERIOD + 120) // just over DHT CHECK_PERIOD
void printConnectState(peerConnectState &peer);
peerConnectAddress::peerConnectAddress()
:delay(0), period(0), type(0), ts(0)
{
sockaddr_clear(&addr);
}
peerAddrInfo::peerAddrInfo()
:found(false), type(0), ts(0)
{
sockaddr_clear(&laddr);
sockaddr_clear(&raddr);
}
peerConnectState::peerConnectState()
:id("unknown"),
netMode(RS_NET_MODE_UNKNOWN), visState(RS_VIS_STATE_STD),
lastcontact(0),
connecttype(0),
lastavailable(0),
lastattempt(0),
name("nameless"), state(0), actions(0),
source(0),
inConnAttempt(0)
{
sockaddr_clear(&localaddr);
sockaddr_clear(&serveraddr);
return;
}
std::string textPeerConnectState(peerConnectState &state)
{
std::ostringstream out;
out << "Id: " << state.id << std::endl;
out << "NetMode: " << state.netMode << std::endl;
out << "VisState: " << state.visState << std::endl;
out << "laddr: " << inet_ntoa(state.localaddr.sin_addr)
<< ":" << ntohs(state.localaddr.sin_port) << std::endl;
out << "eaddr: " << inet_ntoa(state.serveraddr.sin_addr)
<< ":" << ntohs(state.serveraddr.sin_port) << std::endl;
std::string output = out.str();
return output;
}
p3ConnectMgr::p3ConnectMgr(p3AuthMgr *am)
:p3Config(CONFIG_TYPE_PEERS),
mAuthMgr(am), mNetStatus(RS_NET_UNKNOWN),
mStunStatus(0), mStunFound(0), mStunMoreRequired(true),
mStatusChanged(false)
{
mUpnpAddrValid = false;
mStunAddrValid = false;
mStunAddrStable = false;
/* setup basics of own state */
if (am)
{
ownState.id = mAuthMgr->OwnId();
ownState.name = mAuthMgr->getName(ownState.id);
ownState.netMode = RS_NET_MODE_UDP;
}
//use_extr_addr_finder = true ;
use_extr_addr_finder = false;
mExtAddrFinder = new ExtAddrFinder ;
return;
}
void p3ConnectMgr::getIPServersList(std::list<std::string>& ip_servers)
{
mExtAddrFinder->getIPServersList(ip_servers);
}
void p3ConnectMgr::setIPServersEnabled(bool b)
{
use_extr_addr_finder = b ;
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
std::cerr << "p3ConnectMgr: setIPServers to " << b << std::endl ;
}
void p3ConnectMgr::setOwnNetConfig(uint32_t netMode, uint32_t visState)
{
/* only change TRY flags */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::setOwnNetConfig()" << std::endl;
std::cerr << "Existing netMode: " << ownState.netMode << " vis: " << ownState.visState;
std::cerr << std::endl;
std::cerr << "Input netMode: " << netMode << " vis: " << visState;
std::cerr << std::endl;
#endif
ownState.netMode &= ~(RS_NET_MODE_TRYMODE);
#ifdef CONN_DEBUG
std::cerr << "After Clear netMode: " << ownState.netMode << " vis: " << ownState.visState;
std::cerr << std::endl;
#endif
switch(netMode & RS_NET_MODE_ACTUAL)
{
case RS_NET_MODE_EXT:
ownState.netMode |= RS_NET_MODE_TRY_EXT;
break;
case RS_NET_MODE_UPNP:
ownState.netMode |= RS_NET_MODE_TRY_UPNP;
break;
default:
case RS_NET_MODE_UDP:
ownState.netMode |= RS_NET_MODE_TRY_UDP;
break;
}
ownState.visState = visState;
#ifdef CONN_DEBUG
std::cerr << "Final netMode: " << ownState.netMode << " vis: " << ownState.visState;
std::cerr << std::endl;
#endif
/* if we've started up - then tweak Dht On/Off */
if (mNetStatus != RS_NET_UNKNOWN)
{
enableNetAssistConnect(!(ownState.visState & RS_VIS_STATE_NODHT));
}
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
}
/***** Framework / initial implementation for a connection manager.
*
* This needs a state machine for Initialisation.
*
* Network state:
* RS_NET_UNKNOWN
* RS_NET_EXT_UNKNOWN * forwarded port (but Unknown Ext IP) *
* RS_NET_EXT_KNOWN * forwarded port with known IP/Port. *
*
* RS_NET_UPNP_CHECK * checking for UPnP *
* RS_NET_UPNP_KNOWN * confirmed UPnP ext Ip/port *
*
* RS_NET_UDP_UNKNOWN * not Ext/UPnP - to determine Ext IP/Port *
* RS_NET_UDP_KNOWN * have Stunned for Ext Addr *
*
* Transitions:
*
* RS_NET_UNKNOWN -(config)-> RS_NET_EXT_UNKNOWN
* RS_NET_UNKNOWN -(config)-> RS_NET_UPNP_UNKNOWN
* RS_NET_UNKNOWN -(config)-> RS_NET_UDP_UNKNOWN
*
* RS_NET_EXT_UNKNOWN -(DHT(ip)/Stun)-> RS_NET_EXT_KNOWN
*
* RS_NET_UPNP_UNKNOWN -(Upnp)-> RS_NET_UPNP_KNOWN
* RS_NET_UPNP_UNKNOWN -(timout/Upnp)-> RS_NET_UDP_UNKNOWN
*
* RS_NET_UDP_UNKNOWN -(stun)-> RS_NET_UDP_KNOWN
*
*
* STUN state:
* RS_STUN_INIT * done nothing *
* RS_STUN_DHT * looking up peers *
* RS_STUN_DONE * found active peer and stunned *
*
*
* Steps.
*******************************************************************
* (1) Startup.
* - UDP port setup.
* - DHT setup.
* - Get Stun Keys -> add to DHT.
* - Feedback from DHT -> ask UDP to stun.
*
* (1) determine Network mode.
* If external Port.... Done:
* (2)
*******************************************************************
* Stable operation:
* (1) tick and check peers.
* (2) handle callback.
* (3) notify of new/failed connections.
*
*
*/
/* Called to reseet the whole network stack. this call is
* triggered by udp stun address tracking.
*
* must:
* - reset UPnP and DHT.
* -
*/
void p3ConnectMgr::netReset()
{
std::cerr << "p3ConnectMgr::netReset()" << std::endl;
std::cerr << "p3ConnectMgr::netReset() shutdown" << std::endl;
shutdown(); /* blocking shutdown call */
std::cerr << "p3ConnectMgr::netReset() reset NetStatus" << std::endl;
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
mNetStatus = RS_NET_UNKNOWN;
}
std::cerr << "p3ConnectMgr::netReset() checkNetAddress" << std::endl;
/* check Network Address */
checkNetAddress();
/* reset udp network - handled by tou_init! */
/* reset tcp network - if necessary */
{
/* NOTE: nNetListeners should be protected via the Mutex.
* HOWEVER, as we NEVER change this list - once its setup
* we can get away without it - and assume its constant.
*
* NB: (*it)->reset_listener must be out of the mutex,
* as it calls back to p3ConnMgr.
*/
std::cerr << "p3ConnectMgr::netReset() resetting listeners" << std::endl;
std::list<pqiNetListener *>::const_iterator it;
for(it = mNetListeners.begin(); it != mNetListeners.end(); it++)
{
std::cerr << "p3ConnectMgr::netReset() reset listener" << std::endl;
(*it)->reset_listener();
}
}
std::cerr << "p3ConnectMgr::netReset() done" << std::endl;
}
/* to allow resets of network stuff */
void p3ConnectMgr::addNetListener(pqiNetListener *listener)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
mNetListeners.push_back(listener);
}
void p3ConnectMgr::netStatusReset()
{
netFlagOk = true;
netFlagUpnpOk = false;
netFlagDhtOk = false;
netFlagExtOk = false;
netFlagUdpOk = false;
netFlagTcpOk = false;
netFlagResetReq = false;
}
void p3ConnectMgr::netStartup()
{
/* startup stuff */
/* StunInit gets a list of peers, and asks the DHT to find them...
* This is needed for all systems so startup straight away
*/
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netStartup()" << std::endl;
#endif
netDhtInit();
netUdpInit();
netStunInit();
netStatusReset();
/* decide which net setup mode we're going into
*/
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
mNetInitTS = time(NULL);
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netStartup() tou_stunkeepalive() enabled" << std::endl;
#endif
tou_stunkeepalive(1);
mStunMoreRequired = true;
ownState.netMode &= ~(RS_NET_MODE_ACTUAL);
switch(ownState.netMode & RS_NET_MODE_TRYMODE)
{
case RS_NET_MODE_TRY_EXT: /* v similar to UDP */
ownState.netMode |= RS_NET_MODE_EXT;
mNetStatus = RS_NET_UDP_SETUP;
break;
case RS_NET_MODE_TRY_UDP:
ownState.netMode |= RS_NET_MODE_UDP;
mNetStatus = RS_NET_UDP_SETUP;
break;
case RS_NET_MODE_TRY_UPNP:
default:
/* Force it here (could be default!) */
ownState.netMode |= RS_NET_MODE_TRY_UPNP;
ownState.netMode |= RS_NET_MODE_UDP; /* set to UDP, upgraded is UPnP is Okay */
mNetStatus = RS_NET_UPNP_INIT;
break;
}
}
void p3ConnectMgr::tick()
{
netTick();
statusTick();
tickMonitors();
}
bool p3ConnectMgr::shutdown() /* blocking shutdown call */
{
connMtx.lock(); /* LOCK MUTEX */
bool upnpActive = ownState.netMode & RS_NET_MODE_UPNP;
connMtx.unlock(); /* UNLOCK MUTEX */
if (upnpActive)
{
netAssistFirewallShutdown();
}
netAssistConnectShutdown();
return true;
}
void p3ConnectMgr::statusTick()
{
/* iterate through peers ...
* if been available for long time ... remove flag
* if last attempt a while - retryConnect.
* etc.
*/
#ifdef CONN_DEBUG
//std::cerr << "p3ConnectMgr::statusTick()" << std::endl;
#endif
std::list<std::string> retryIds;
std::list<std::string>::iterator it2;
time_t now = time(NULL);
time_t oldavail = now - MAX_AVAIL_PERIOD;
time_t retry = now - MIN_RETRY_PERIOD;
{
RsStackMutex stack(connMtx); /****** LOCK MUTEX ******/
std::map<std::string, peerConnectState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{
if (it->second.state & RS_PEER_S_CONNECTED)
{
continue;
}
if ((it->second.state & RS_PEER_S_ONLINE) &&
(it->second.lastavailable < oldavail))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::statusTick() ONLINE TIMEOUT for: ";
std::cerr << it->first;
std::cerr << std::endl;
#endif
it->second.state &= (~RS_PEER_S_ONLINE);
}
if (it->second.lastattempt < retry)
{
retryIds.push_back(it->first);
}
}
}
#ifndef P3CONNMGR_NO_AUTO_CONNECTION
for(it2 = retryIds.begin(); it2 != retryIds.end(); it2++)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::statusTick() RETRY TIMEOUT for: ";
std::cerr << *it2;
std::cerr << std::endl;
#endif
/* retry it! */
retryConnectTCP(*it2);
}
#endif
}
void p3ConnectMgr::netTick()
{
#ifdef CONN_DEBUG
//std::cerr << "p3ConnectMgr::netTick()" << std::endl;
#endif
// Check whether we are stuck on loopback. This happens if RS starts when
// the computer is not yet connected to the internet. In such a case we
// periodically check for a local net address.
//
if(isLoopbackNet(&(ownState.localaddr.sin_addr)))
checkNetAddress() ;
connMtx.lock(); /* LOCK MUTEX */
uint32_t netStatus = mNetStatus;
connMtx.unlock(); /* UNLOCK MUTEX */
switch(netStatus)
{
case RS_NET_UNKNOWN:
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netTick() STATUS: UNKNOWN" << std::endl;
#endif
/* RS_NET_UNKNOWN -(config)-> RS_NET_EXT_INIT
* RS_NET_UNKNOWN -(config)-> RS_NET_UPNP_INIT
* RS_NET_UNKNOWN -(config)-> RS_NET_UDP_INIT
*/
netStartup();
break;
case RS_NET_UPNP_INIT:
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netTick() STATUS: UPNP_INIT" << std::endl;
#endif
netUpnpInit();
break;
case RS_NET_UPNP_SETUP:
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netTick() STATUS: UPNP_SETUP" << std::endl;
#endif
netUpnpCheck();
break;
case RS_NET_UDP_SETUP:
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netTick() STATUS: UDP_SETUP" << std::endl;
#endif
netUdpCheck();
break;
case RS_NET_DONE:
#ifdef CONN_DEBUG
//std::cerr << "p3ConnectMgr::netTick() STATUS: DONE" << std::endl;
#endif
stunCheck(); /* Keep on stunning until its happy */
default:
break;
}
return;
}
void p3ConnectMgr::netUdpInit()
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netUdpInit()" << std::endl;
#endif
connMtx.lock(); /* LOCK MUTEX */
struct sockaddr_in iaddr = ownState.localaddr;
connMtx.unlock(); /* UNLOCK MUTEX */
/* open our udp port */
tou_init((struct sockaddr *) &iaddr, sizeof(iaddr));
}
void p3ConnectMgr::netDhtInit()
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netDhtInit()" << std::endl;
#endif
connMtx.lock(); /* LOCK MUTEX */
uint32_t vs = ownState.visState;
connMtx.unlock(); /* UNLOCK MUTEX */
enableNetAssistConnect(!(vs & RS_VIS_STATE_NODHT));
}
void p3ConnectMgr::netUpnpInit()
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netUpnpInit()" << std::endl;
#endif
uint16_t eport, iport;
connMtx.lock(); /* LOCK MUTEX */
/* get the ports from the configuration */
mNetStatus = RS_NET_UPNP_SETUP;
iport = ntohs(ownState.localaddr.sin_port);
eport = ntohs(ownState.serveraddr.sin_port);
if ((eport < 1000) || (eport > 30000))
{
eport = iport;
}
connMtx.unlock(); /* UNLOCK MUTEX */
netAssistFirewallPorts(iport, eport);
enableNetAssistFirewall(true);
}
void p3ConnectMgr::netUpnpCheck()
{
/* grab timestamp */
connMtx.lock(); /* LOCK MUTEX */
time_t delta = time(NULL) - mNetInitTS;
connMtx.unlock(); /* UNLOCK MUTEX */
struct sockaddr_in extAddr;
int upnpState = netAssistFirewallActive();
if ((upnpState < 0) ||
((upnpState == 0) && (delta > MAX_UPNP_INIT)))
{
/* fallback to UDP startup */
connMtx.lock(); /* LOCK MUTEX */
/* UPnP Failed us! */
mUpnpAddrValid = false;
mNetStatus = RS_NET_UDP_SETUP;
connMtx.unlock(); /* UNLOCK MUTEX */
}
else if ((upnpState > 0) && netAssistExtAddress(extAddr))
{
/* switch to UDP startup */
connMtx.lock(); /* LOCK MUTEX */
/* Set Net Status flags ....
* we now have external upnp address. Golden!
* don't set netOk flag until have seen some traffic.
*/
netFlagUpnpOk = true;
netFlagExtOk = true;
mUpnpAddrValid = true;
mUpnpExtAddr = extAddr;
mNetStatus = RS_NET_UDP_SETUP;
/* Fix netMode & Clear others! */
ownState.netMode = RS_NET_MODE_TRY_UPNP | RS_NET_MODE_UPNP;
connMtx.unlock(); /* UNLOCK MUTEX */
}
}
void p3ConnectMgr::netUdpCheck()
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netUdpCheck()" << std::endl;
#endif
struct sockaddr_in tmpip ;
if (udpExtAddressCheck() || (mUpnpAddrValid) || (use_extr_addr_finder && mExtAddrFinder->hasValidIP(&tmpip)))
{
bool extValid = false;
bool extAddrStable = false;
struct sockaddr_in extAddr;
uint32_t mode = 0;
connMtx.lock(); /* LOCK MUTEX */
mNetStatus = RS_NET_DONE;
/* get the addr from the configuration */
struct sockaddr_in iaddr = ownState.localaddr;
if (mUpnpAddrValid)
{
extValid = true;
extAddr = mUpnpExtAddr;
extAddrStable = true;
}
else if (mStunAddrValid)
{
extValid = true;
extAddr = mStunExtAddr;
extAddrStable = mStunAddrStable;
}
else if(use_extr_addr_finder && mExtAddrFinder->hasValidIP(&tmpip))
{
extValid = true;
extAddr = tmpip ;
extAddr.sin_port = iaddr.sin_port ;
extAddrStable = true;
}
if (extValid)
{
ownState.serveraddr = extAddr;
mode = RS_NET_CONN_TCP_LOCAL;
if (!extAddrStable)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netUdpCheck() UDP Unstable :( ";
std::cerr << std::endl;
std::cerr << "p3ConnectMgr::netUdpCheck() We are unreachable";
std::cerr << std::endl;
std::cerr << "netMode => RS_NET_MODE_UNREACHABLE";
std::cerr << std::endl;
#endif
ownState.netMode &= ~(RS_NET_MODE_ACTUAL);
ownState.netMode |= RS_NET_MODE_UNREACHABLE;
/* send a system warning message */
pqiNotify *notify = getPqiNotify();
if (notify)
{
std::string title =
"Warning: Bad Firewall Configuration";
std::string msg;
msg += " **** WARNING **** \n";
msg += "Retroshare has detected that you are behind";
msg += " a restrictive Firewall\n";
msg += "\n";
msg += "You cannot connect to other firewalled peers\n";
msg += "\n";
msg += "You can fix this by:\n";
msg += " (1) opening an External Port\n";
msg += " (2) enabling UPnP, or\n";
msg += " (3) get a new (approved) Firewall/Router\n";
notify->AddSysMessage(0, RS_SYS_WARNING, title, msg);
}
}
else if (mUpnpAddrValid || (ownState.netMode & RS_NET_MODE_EXT))
{
mode |= RS_NET_CONN_TCP_EXTERNAL;
mode |= RS_NET_CONN_UDP_DHT_SYNC;
}
else // if (extAddrStable)
{
/* Check if extAddr == intAddr (Not Firewalled) */
if ((0 == inaddr_cmp(iaddr, extAddr)) &&
isExternalNet(&(extAddr.sin_addr)))
{
mode |= RS_NET_CONN_TCP_EXTERNAL;
}
mode |= RS_NET_CONN_UDP_DHT_SYNC;
}
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
}
connMtx.unlock(); /* UNLOCK MUTEX */
if (extValid)
{
netAssistSetAddress(iaddr, extAddr, mode);
}
else
{
/* mode = 0 for error */
netAssistSetAddress(iaddr, extAddr, mode);
}
/* flag unreachables! */
if ((extValid) && (!extAddrStable))
{
netUnreachableCheck();
}
}
}
void p3ConnectMgr::netUnreachableCheck()
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::netUnreachableCheck()" << std::endl;
#endif
std::map<std::string, peerConnectState>::iterator it;
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{
/* get last contact detail */
if (it->second.state & RS_PEER_S_CONNECTED)
{
#ifdef CONN_DEBUG
std::cerr << "NUC() Ignoring Connected Peer" << std::endl;
#endif
continue;
}
peerAddrInfo details;
switch(it->second.source)
{
case RS_CB_DHT:
details = it->second.dht;
#ifdef CONN_DEBUG
std::cerr << "NUC() Using DHT data" << std::endl;
#endif
break;
case RS_CB_DISC:
details = it->second.disc;
#ifdef CONN_DEBUG
std::cerr << "NUC() Using DISC data" << std::endl;
#endif
break;
case RS_CB_PERSON:
details = it->second.peer;
#ifdef CONN_DEBUG
std::cerr << "NUC() Using PEER data" << std::endl;
#endif
break;
default:
continue;
break;
}
std::cerr << "NUC() Peer: " << it->first << std::endl;
/* Determine Reachability (only advisory) */
// if (ownState.netMode == RS_NET_MODE_UNREACHABLE) // MUST BE TRUE!
{
if (details.type & RS_NET_CONN_TCP_EXTERNAL)
{
/* reachable! */
it->second.state &= (~RS_PEER_S_UNREACHABLE);
#ifdef CONN_DEBUG
std::cerr << "NUC() Peer EXT TCP - reachable" << std::endl;
#endif
}
else
{
/* unreachable */
it->second.state |= RS_PEER_S_UNREACHABLE;
#ifdef CONN_DEBUG
std::cerr << "NUC() Peer !EXT TCP - unreachable" << std::endl;
#endif
}
}
}
}
/******************************* UDP MAINTAINANCE ********************************
* Interaction with the UDP is mainly for determining the External Port.
*
*/
bool p3ConnectMgr::udpInternalAddress(struct sockaddr_in iaddr)
{
return false;
}
bool p3ConnectMgr::udpExtAddressCheck()
{
/* three possibilities:
* (1) not found yet.
* (2) Found!
* (3) bad udp (port switching).
*/
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
uint8_t stable;
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::udpExtAddressCheck()" << std::endl;
#endif
if (0 < tou_extaddr((struct sockaddr *) &addr, &len, &stable))
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* update UDP information */
mStunExtAddr = addr;
mStunAddrValid = true;
mStunAddrStable = (stable != 0);
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::udpExtAddressCheck() Got ";
std::cerr << " addr: " << inet_ntoa(mStunExtAddr.sin_addr);
std::cerr << ":" << ntohs(mStunExtAddr.sin_port);
std::cerr << " stable: " << mStunAddrStable;
std::cerr << std::endl;
#endif
/* update net Status flags ....
* we've got stun information via udp...
* so up is okay, and ext address is known stable or not.
*/
if (mStunAddrStable)
netFlagExtOk = true;
netFlagUdpOk = true;
return true;
}
return false;
}
void p3ConnectMgr::udpStunPeer(std::string id, struct sockaddr_in &addr)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::udpStunPeer()" << std::endl;
#endif
/* add it into udp stun list */
tou_stunpeer((struct sockaddr *) &addr, sizeof(addr), id.c_str());
}
/********************************** STUN SERVERS ***********************************
* We maintain a list of stun servers. This is initialised with a set of random keys.
*
* This is gradually rolled over with time. We update with friends/friends of friends,
* and the lists that they provide (part of AutoDisc).
*
* max 100 entries?
*/
void p3ConnectMgr::netStunInit()
{
stunInit();
}
void p3ConnectMgr::stunInit()
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
netAssistStun(true);
/* push stun list to DHT */
std::list<std::string>::iterator it;
for(it = mStunList.begin(); it != mStunList.end(); it++)
{
netAssistAddStun(*it);
}
mStunStatus = RS_STUN_DHT;
mStunFound = 0;
mStunMoreRequired = true;
}
/* This is continually called
*
* checks whether the ext address is consistent
*
* checks if UDP needs more stun peers - or not
* The status is passed onto the DHT.
*
*/
bool p3ConnectMgr::stunCheck()
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::stunCheck()" << std::endl;
#endif
/* check udp address stability */
bool netDone = false;
bool doNetReset = false;
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
mStunStatus = RS_STUN_DHT;
netDone = (mNetStatus == RS_NET_DONE);
}
struct sockaddr_in raddr;
socklen_t rlen = sizeof(raddr);
struct sockaddr_in eaddr;
socklen_t elen = sizeof(eaddr);
uint8_t stable;
uint32_t failCount;
time_t lastSent;
time_t now = time(NULL);
if (netDone)
{
#ifdef CONN_DEBUG
std::cerr << "NetSetupDone: Checking if network is same" << std::endl;
#endif
if (0 < tou_extaddr((struct sockaddr *) &raddr, &rlen, &stable))
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
if ((mStunExtAddr.sin_addr.s_addr != raddr.sin_addr.s_addr) ||
(mStunAddrStable != stable))
{
#ifdef CONN_DEBUG
std::cerr << "Ext Address Changed -> netReset" << std::endl;
#endif
doNetReset = true;
}
else
{
#ifdef CONN_DEBUG
std::cerr << "Ext Address Same: ok!" << std::endl;
#endif
}
}
else
{
#ifdef CONN_DEBUG
std::cerr << "No Ext Address -> netReset" << std::endl;
#endif
doNetReset = true;
}
}
if (doNetReset)
{
#ifdef CONN_DEBUG
std::cerr << "Resetting Network" << std::endl;
#endif
netReset();
}
#ifdef CONN_DEBUG
int i = 0;
for(i = 0; tou_getstunpeer(i, (struct sockaddr *) &raddr, &rlen,
(struct sockaddr *) &eaddr, &elen,
&failCount, &lastSent); i++)
{
std::cerr << "STUN PEERS: ";
std::cerr << " raddr: " << inet_ntoa(raddr.sin_addr) << ":" << ntohs(raddr.sin_port);
std::cerr << " eaddr: " << inet_ntoa(eaddr.sin_addr) << ":" << ntohs(eaddr.sin_port);
if (lastSent)
{
std::cerr << " failCount: " << failCount << " lastSent: " << now-lastSent;
}
else
{
std::cerr << " Unused ";
}
std::cerr << std::endl;
}
#endif
/* pass on udp status to dht */
if (tou_needstunpeers())
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
if (!mStunMoreRequired)
{
#ifdef CONN_DEBUG
std::cerr << "Telling DHT More Stun Required" << std::endl;
#endif
netAssistStun(true);
mStunMoreRequired = true;
}
}
else
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
if (mStunMoreRequired)
{
#ifdef CONN_DEBUG
std::cerr << "Telling DHT No More Stun Required" << std::endl;
#endif
netAssistStun(false);
mStunMoreRequired = false;
}
}
return true;
}
void p3ConnectMgr::stunStatus(std::string id, struct sockaddr_in raddr, uint32_t type, uint32_t flags)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::stunStatus()";
std::cerr << " id: " << RsUtil::BinToHex(id) << " raddr: " << inet_ntoa(raddr.sin_addr);
std::cerr << ":" << ntohs(raddr.sin_port);
std::cerr << std::endl;
#endif
connMtx.lock(); /* LOCK MUTEX */
bool stillStunning = (mStunStatus == RS_STUN_DHT);
connMtx.unlock(); /* UNLOCK MUTEX */
/* only useful if they have an exposed TCP/UDP port */
if (type & RS_NET_CONN_TCP_EXTERNAL)
{
if (stillStunning)
{
connMtx.lock(); /* LOCK MUTEX */
mStunFound++;
connMtx.unlock(); /* UNLOCK MUTEX */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::stunStatus() Sending to UDP" << std::endl;
#endif
/* push to the UDP */
udpStunPeer(id, raddr);
}
/* push to the stunCollect */
stunCollect(id, raddr, flags);
}
}
/* FLAGS
ONLINE
EXT
UPNP
UDP
FRIEND
FRIEND_OF_FRIEND
OTHER
*/
void p3ConnectMgr::stunCollect(std::string id, struct sockaddr_in addr, uint32_t flags)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::stunCollect() id: " << RsUtil::BinToHex(id) << std::endl;
#endif
std::list<std::string>::iterator it;
it = std::find(mStunList.begin(), mStunList.end(), id);
if (it == mStunList.end())
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::stunCollect() Id not in List" << std::endl;
#endif
/* add it in:
* if FRIEND / ONLINE or if list is short.
*/
if ((flags & RS_STUN_ONLINE) || (flags & RS_STUN_FRIEND))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::stunCollect() Id added to Front" << std::endl;
#endif
/* push to the front */
mStunList.push_front(id);
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
}
else if (mStunList.size() < RS_STUN_LIST_MIN)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::stunCollect() Id added to Back" << std::endl;
#endif
/* push to the front */
mStunList.push_back(id);
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
}
}
else
{
/* if they're online ... move to the front
*/
if (flags & RS_STUN_ONLINE)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::stunCollect() Id moved to Front" << std::endl;
#endif
/* move to front */
mStunList.erase(it);
mStunList.push_front(id);
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
}
}
}
/******************************** Network Status *********************************
* Configuration Loading / Saving.
*/
void p3ConnectMgr::addMonitor(pqiMonitor *mon)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
std::list<pqiMonitor *>::iterator it;
it = std::find(clients.begin(), clients.end(), mon);
if (it != clients.end())
{
return;
}
mon->setConnectionMgr(this);
clients.push_back(mon);
return;
}
void p3ConnectMgr::removeMonitor(pqiMonitor *mon)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
std::list<pqiMonitor *>::iterator it;
it = std::find(clients.begin(), clients.end(), mon);
if (it == clients.end())
{
return;
}
(*it)->setConnectionMgr(NULL);
clients.erase(it);
return;
}
void p3ConnectMgr::tickMonitors()
{
bool doStatusChange = false;
std::list<pqipeer> actionList;
std::map<std::string, peerConnectState>::iterator it;
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
if (mStatusChanged)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::tickMonitors() StatusChanged! List:" << std::endl;
#endif
/* assemble list */
for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{
if (it->second.actions)
{
/* add in */
pqipeer peer;
peer.id = it->second.id;
peer.name = it->second.name;
peer.state = it->second.state;
peer.actions = it->second.actions;
/* reset action */
it->second.actions = 0;
actionList.push_back(peer);
#ifdef CONN_DEBUG
std::cerr << "Friend: " << peer.name;
std::cerr << " Id: " << peer.id;
std::cerr << " State: " << peer.state;
if (peer.state & RS_PEER_S_FRIEND)
std::cerr << " S:RS_PEER_S_FRIEND";
if (peer.state & RS_PEER_S_ONLINE)
std::cerr << " S:RS_PEER_S_ONLINE";
if (peer.state & RS_PEER_S_CONNECTED)
std::cerr << " S:RS_PEER_S_CONNECTED";
std::cerr << " Actions: " << peer.actions;
if (peer.actions & RS_PEER_NEW)
std::cerr << " A:RS_PEER_NEW";
if (peer.actions & RS_PEER_MOVED)
std::cerr << " A:RS_PEER_MOVED";
if (peer.actions & RS_PEER_CONNECTED)
std::cerr << " A:RS_PEER_CONNECTED";
if (peer.actions & RS_PEER_DISCONNECTED)
std::cerr << " A:RS_PEER_DISCONNECTED";
if (peer.actions & RS_PEER_CONNECT_REQ)
std::cerr << " A:RS_PEER_CONNECT_REQ";
std::cerr << std::endl;
#endif
/* notify GUI */
if (peer.actions & RS_PEER_CONNECTED)
{
pqiNotify *notify = getPqiNotify();
if (notify)
{
notify->AddPopupMessage(RS_POPUP_CONNECT,
peer.id, "Online: ");
notify->AddFeedItem(RS_FEED_ITEM_PEER_CONNECT, peer.id, "", "");
}
}
#if 0
if (peer.actions & RS_PEER_DISCONNECTED)
{
pqiNotify *notify = getPqiNotify();
if (notify)
{
notify->AddFeedItem(RS_FEED_ITEM_PEER_DISCONNECT, peer.id, "", "");
}
}
#endif
}
}
/* do the Others as well! */
for(it = mOthersList.begin(); it != mOthersList.end(); it++)
{
if (it->second.actions)
{
/* add in */
pqipeer peer;
peer.id = it->second.id;
peer.name = it->second.name;
peer.state = it->second.state;
peer.actions = it->second.actions;
/* reset action */
it->second.actions = 0;
#ifdef CONN_DEBUG
std::cerr << "Other: " << peer.name;
std::cerr << " Id: " << peer.id;
std::cerr << " State: " << peer.state;
if (peer.state & RS_PEER_S_FRIEND)
std::cerr << " S:RS_PEER_S_FRIEND";
if (peer.state & RS_PEER_S_ONLINE)
std::cerr << " S:RS_PEER_S_ONLINE";
if (peer.state & RS_PEER_S_CONNECTED)
std::cerr << " S:RS_PEER_S_CONNECTED";
std::cerr << " Actions: " << peer.actions;
if (peer.actions & RS_PEER_NEW)
std::cerr << " A:RS_PEER_NEW";
if (peer.actions & RS_PEER_MOVED)
std::cerr << " A:RS_PEER_MOVED";
if (peer.actions & RS_PEER_CONNECTED)
std::cerr << " A:RS_PEER_CONNECTED";
if (peer.actions & RS_PEER_DISCONNECTED)
std::cerr << " A:RS_PEER_DISCONNECTED";
if (peer.actions & RS_PEER_CONNECT_REQ)
std::cerr << " A:RS_PEER_CONNECT_REQ";
std::cerr << std::endl;
#endif
actionList.push_back(peer);
}
}
mStatusChanged = false;
doStatusChange = true;
}
} /****** UNLOCK STACK MUTEX ******/
/* NOTE - clients is accessed without mutex protection!!!!
* At the moment this is okay - as they are only added at the start.
* IF this changes ---- must fix with second Mutex.
*/
if (doStatusChange)
{
#ifdef CONN_DEBUG
std::cerr << "Sending to " << clients.size() << " monitorClients";
std::cerr << std::endl;
#endif
/* send to all monitors */
std::list<pqiMonitor *>::iterator mit;
for(mit = clients.begin(); mit != clients.end(); mit++)
{
(*mit)->statusChange(actionList);
}
}
}
const std::string p3ConnectMgr::getOwnId()
{
if (mAuthMgr)
{
return mAuthMgr->OwnId();
}
else
{
std::string nullStr;
return nullStr;
}
}
bool p3ConnectMgr::getOwnNetStatus(peerConnectState &state)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
state = ownState;
return true;
}
bool p3ConnectMgr::isFriend(std::string id)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
return (mFriendList.end() != mFriendList.find(id));
}
bool p3ConnectMgr::isOnline(std::string id)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() != (it = mFriendList.find(id)))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::isOnline(" << id;
std::cerr << ") is Friend, Online: ";
std::cerr << (it->second.state & RS_PEER_S_CONNECTED);
std::cerr << std::endl;
#endif
return (it->second.state & RS_PEER_S_CONNECTED);
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::isOnline(" << id;
std::cerr << ") is Not Friend";
std::cerr << std::endl;
std::cerr << "p3ConnectMgr::isOnline() OwnId: ";
std::cerr << mAuthMgr->OwnId();
std::cerr << std::endl;
#endif
/* not a friend */
}
return false;
}
bool p3ConnectMgr::getFriendNetStatus(std::string id, peerConnectState &state)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerConnectState>::iterator it;
it = mFriendList.find(id);
if (it == mFriendList.end())
{
return false;
}
state = it->second;
return true;
}
bool p3ConnectMgr::getOthersNetStatus(std::string id, peerConnectState &state)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerConnectState>::iterator it;
it = mOthersList.find(id);
if (it == mOthersList.end())
{
return false;
}
state = it->second;
return true;
}
void p3ConnectMgr::getOnlineList(std::list<std::string> &peers)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerConnectState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{
if (it->second.state & RS_PEER_S_CONNECTED)
{
peers.push_back(it->first);
}
}
return;
}
void p3ConnectMgr::getFriendList(std::list<std::string> &peers)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerConnectState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{
peers.push_back(it->first);
}
return;
}
void p3ConnectMgr::getOthersList(std::list<std::string> &peers)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerConnectState>::iterator it;
for(it = mOthersList.begin(); it != mOthersList.end(); it++)
{
peers.push_back(it->first);
}
return;
}
bool p3ConnectMgr::connectAttempt(std::string id, struct sockaddr_in &addr,
uint32_t &delay, uint32_t &period, uint32_t &type)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerConnectState>::iterator it;
it = mFriendList.find(id);
if (it == mFriendList.end())
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::connectAttempt() FAILED Not in FriendList!";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
return false;
}
if (it->second.connAddrs.size() < 1)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::connectAttempt() FAILED No ConnectAddresses";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
return false;
}
it->second.lastattempt = time(NULL); /* time of last connect attempt */
it->second.inConnAttempt = true;
it->second.currentConnAddr = it->second.connAddrs.front();
it->second.connAddrs.pop_front();
addr = it->second.currentConnAddr.addr;
delay = it->second.currentConnAddr.delay;
period = it->second.currentConnAddr.period;
type = it->second.currentConnAddr.type;
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::connectAttempt() Success: ";
std::cerr << " id: " << id;
std::cerr << std::endl;
std::cerr << " laddr: " << inet_ntoa(addr.sin_addr);
std::cerr << " lport: " << ntohs(addr.sin_port);
std::cerr << " delay: " << delay;
std::cerr << " period: " << period;
std::cerr << " type: " << type;
std::cerr << std::endl;
#endif
return true;
}
/****************************
* Update state,
* trigger retry if necessary,
*
* remove from DHT?
*
*/
bool p3ConnectMgr::connectResult(std::string id, bool success, uint32_t flags)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerConnectState>::iterator it;
it = mFriendList.find(id);
if (it == mFriendList.end())
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::connectResult() Failed, missing Friend ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
return false;
}
it->second.inConnAttempt = false;
if (success)
{
/* remove other attempts */
it->second.connAddrs.clear();
netAssistFriend(id, false);
/* update address (will come through from DISC) */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::connectResult() Connect!: ";
std::cerr << " id: " << id;
std::cerr << std::endl;
std::cerr << " Success: " << success;
std::cerr << " flags: " << flags;
std::cerr << std::endl;
#endif
/* change state */
it->second.state |= RS_PEER_S_CONNECTED;
it->second.actions |= RS_PEER_CONNECTED;
mStatusChanged = true;
it->second.lastcontact = time(NULL); /* time of connect */
it->second.connecttype = flags;
return true;
}
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::connectResult() Disconnect/Fail: ";
std::cerr << " id: " << id;
std::cerr << std::endl;
std::cerr << " Success: " << success;
std::cerr << " flags: " << flags;
std::cerr << std::endl;
#endif
/* if currently connected -> flag as failed */
if (it->second.state & RS_PEER_S_CONNECTED)
{
it->second.state &= (~RS_PEER_S_CONNECTED);
it->second.actions |= RS_PEER_DISCONNECTED;
it->second.lastcontact = time(NULL); /* time of disconnect */
netAssistFriend(id, true);
if (it->second.visState & RS_VIS_STATE_NODHT)
{
/* hidden from DHT world */
}
else
{
//netAssistFriend(id, true);
}
}
if (it->second.connAddrs.size() < 1)
{
return true;
}
it->second.actions |= RS_PEER_CONNECT_REQ;
mStatusChanged = true;
return true;
}
/******************************** Feedback ...... *********************************
* From various sources
*/
void p3ConnectMgr::peerStatus(std::string id,
struct sockaddr_in laddr, struct sockaddr_in raddr,
uint32_t type, uint32_t flags, uint32_t source)
{
std::map<std::string, peerConnectState>::iterator it;
bool isFriend = true;
time_t now = time(NULL);
peerAddrInfo details;
details.type = type;
details.found = true;
details.laddr = laddr;
details.raddr = raddr;
details.ts = now;
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus()";
std::cerr << " id: " << id;
std::cerr << " laddr: " << inet_ntoa(laddr.sin_addr);
std::cerr << " lport: " << ntohs(laddr.sin_port);
std::cerr << " raddr: " << inet_ntoa(raddr.sin_addr);
std::cerr << " rport: " << ntohs(raddr.sin_port);
std::cerr << " type: " << type;
std::cerr << " flags: " << flags;
std::cerr << " source: " << source;
std::cerr << std::endl;
#endif
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::peerStatus()";
out << " id: " << id;
out << " laddr: " << inet_ntoa(laddr.sin_addr);
out << " lport: " << ntohs(laddr.sin_port);
out << " raddr: " << inet_ntoa(raddr.sin_addr);
out << " rport: " << ntohs(raddr.sin_port);
out << " type: " << type;
out << " flags: " << flags;
out << " source: " << source;
rslog(RSL_WARNING, p3connectzone, out.str());
}
/* look up the id */
it = mFriendList.find(id);
if (it == mFriendList.end())
{
/* check Others list */
isFriend = false;
it = mOthersList.find(id);
if (it == mOthersList.end())
{
/* not found - ignore */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() Peer Not Found - Ignore";
std::cerr << std::endl;
#endif
return;
}
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() Peer is in mOthersList";
std::cerr << std::endl;
#endif
}
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() Current Peer State:" << std::endl;
printConnectState(it->second);
std::cerr << std::endl;
#endif
/* update the status */
/* if source is DHT */
if (source == RS_CB_DHT)
{
/* DHT can tell us about
* 1) connect type (UDP/TCP/etc)
* 2) local/external address
*/
it->second.source = RS_CB_DHT;
it->second.dht = details;
/* If we get a info -> then they are online */
it->second.state |= RS_PEER_S_ONLINE;
it->second.lastavailable = now;
/* if we are recieving these - the dht is definitely up.
*/
netFlagDhtOk = true;
}
else if (source == RS_CB_DISC)
{
/* DISC can tell us about
* 1) connect type (UDP/TCP/etc)
* 2) local/external addresses
*/
it->second.source = RS_CB_DISC;
it->second.disc = details;
if (flags & RS_NET_FLAGS_ONLINE)
{
it->second.actions |= RS_PEER_ONLINE;
it->second.state |= RS_PEER_S_ONLINE;
it->second.lastavailable = now;
mStatusChanged = true;
}
/* not updating VIS status??? */
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
}
else if (source == RS_CB_PERSON)
{
/* PERSON can tell us about
* 1) online / offline
* 2) connect address
* -> update all!
*/
it->second.source = RS_CB_PERSON;
it->second.peer = details;
it->second.localaddr = laddr;
it->second.serveraddr = raddr;
it->second.state |= RS_PEER_S_ONLINE;
it->second.lastavailable = now;
/* must be online to recv info (should be connected too!)
* but no need for action as should be connected already
*/
it->second.netMode &= (~RS_NET_MODE_ACTUAL); /* clear actual flags */
if (flags & RS_NET_FLAGS_EXTERNAL_ADDR)
{
it->second.netMode = RS_NET_MODE_EXT;
}
else if (flags & RS_NET_FLAGS_STABLE_UDP)
{
it->second.netMode = RS_NET_MODE_UDP;
}
else
{
it->second.netMode = RS_NET_MODE_UNREACHABLE;
}
/* always update VIS status */
if (flags & RS_NET_FLAGS_USE_DISC)
{
it->second.visState &= (~RS_VIS_STATE_NODISC);
}
else
{
it->second.visState |= RS_VIS_STATE_NODISC;
}
if (flags & RS_NET_FLAGS_USE_DHT)
{
it->second.visState &= (~RS_VIS_STATE_NODHT);
}
else
{
it->second.visState |= RS_VIS_STATE_NODHT;
}
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
}
/* Determine Reachability (only advisory) */
if (ownState.netMode & RS_NET_MODE_UDP)
{
if ((details.type & RS_NET_CONN_UDP_DHT_SYNC) ||
(details.type & RS_NET_CONN_TCP_EXTERNAL))
{
/* reachable! */
it->second.state &= (~RS_PEER_S_UNREACHABLE);
}
else
{
/* unreachable */
it->second.state |= RS_PEER_S_UNREACHABLE;
}
}
else if (ownState.netMode & RS_NET_MODE_UNREACHABLE)
{
if (details.type & RS_NET_CONN_TCP_EXTERNAL)
{
/* reachable! */
it->second.state &= (~RS_PEER_S_UNREACHABLE);
}
else
{
/* unreachable */
it->second.state |= RS_PEER_S_UNREACHABLE;
}
}
else
{
it->second.state &= (~RS_PEER_S_UNREACHABLE);
}
if (!isFriend)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() NOT FRIEND ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::peerStatus() NO CONNECT (not friend)";
rslog(RSL_WARNING, p3connectzone, out.str());
}
return;
}
/* if already connected -> done */
if (it->second.state & RS_PEER_S_CONNECTED)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() PEER ONLINE ALREADY ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::peerStatus() NO CONNECT (already connected!)";
rslog(RSL_WARNING, p3connectzone, out.str());
}
return;
}
/* are the addresses different? */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus()";
std::cerr << " id: " << id;
std::cerr << " laddr: " << inet_ntoa(laddr.sin_addr);
std::cerr << " lport: " << ntohs(laddr.sin_port);
std::cerr << " raddr: " << inet_ntoa(raddr.sin_addr);
std::cerr << " rport: " << ntohs(raddr.sin_port);
std::cerr << " type: " << type;
std::cerr << " flags: " << flags;
std::cerr << " source: " << source;
std::cerr << std::endl;
#endif
#ifndef P3CONNMGR_NO_AUTO_CONNECTION
#ifndef P3CONNMGR_NO_TCP_CONNECTIONS
/* add in attempts ... local(TCP), remote(TCP)
* udp must come from notify
*/
/* determine delay (for TCP connections)
* this is to ensure that simultaneous connections don't occur
* (which can fail).
* easest way is to compare ids ... and delay one of them
*/
uint32_t tcp_delay = 0;
if (id > ownState.id)
{
tcp_delay = P3CONNMGR_TCP_DEFAULT_DELAY;
}
/* if address is same -> try local */
if ((isValidNet(&(details.laddr.sin_addr))) &&
(sameNet(&(ownState.localaddr.sin_addr), &(details.laddr.sin_addr))))
{
/* add the local address */
peerConnectAddress pca;
pca.ts = now;
pca.delay = tcp_delay;
pca.period = 0;
pca.type = RS_NET_CONN_TCP_LOCAL;
pca.addr = details.laddr;
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() ADDING TCP_LOCAL ADDR: ";
std::cerr << " id: " << id;
std::cerr << " laddr: " << inet_ntoa(pca.addr.sin_addr);
std::cerr << " lport: " << ntohs(pca.addr.sin_port);
std::cerr << " delay: " << pca.delay;
std::cerr << " period: " << pca.period;
std::cerr << " type: " << pca.type;
std::cerr << " source: " << source;
std::cerr << std::endl;
#endif
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::peerStatus() PushBack Local TCP Address: ";
out << " id: " << id;
out << " laddr: " << inet_ntoa(pca.addr.sin_addr);
out << ":" << ntohs(pca.addr.sin_port);
out << " type: " << pca.type;
out << " delay: " << pca.delay;
out << " period: " << pca.period;
out << " ts: " << pca.ts;
out << " source: " << source;
rslog(RSL_WARNING, p3connectzone, out.str());
}
it->second.connAddrs.push_back(pca);
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() Not adding Local Connect (Diff Network)";
std::cerr << " id: " << id;
std::cerr << " laddr: " << inet_ntoa(details.laddr.sin_addr);
std::cerr << ": " << ntohs(details.laddr.sin_port);
std::cerr << " own.laddr: " << inet_ntoa(ownState.localaddr.sin_addr);
std::cerr << ": " << ntohs(ownState.localaddr.sin_port);
std::cerr << std::endl;
#endif
}
if ((details.type & RS_NET_CONN_TCP_EXTERNAL) &&
(isValidNet(&(details.raddr.sin_addr))))
{
/* add the remote address */
peerConnectAddress pca;
pca.ts = now;
pca.delay = tcp_delay;
pca.period = 0;
pca.type = RS_NET_CONN_TCP_EXTERNAL;
pca.addr = details.raddr;
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() ADDING TCP_REMOTE ADDR: ";
std::cerr << " id: " << id;
std::cerr << " raddr: " << inet_ntoa(pca.addr.sin_addr);
std::cerr << " rport: " << ntohs(pca.addr.sin_port);
std::cerr << " delay: " << pca.delay;
std::cerr << " period: " << pca.period;
std::cerr << " type: " << pca.type;
std::cerr << " source: " << source;
std::cerr << std::endl;
#endif
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::peerStatus() PushBack Remote TCP Address: ";
out << " id: " << id;
out << " raddr: " << inet_ntoa(pca.addr.sin_addr);
out << ":" << ntohs(pca.addr.sin_port);
out << " type: " << pca.type;
out << " delay: " << pca.delay;
out << " period: " << pca.period;
out << " ts: " << pca.ts;
out << " source: " << source;
rslog(RSL_WARNING, p3connectzone, out.str());
}
it->second.connAddrs.push_back(pca);
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() Not adding Remote Connect (Type != E or Invalid Network)";
std::cerr << " id: " << id;
std::cerr << " raddr: " << inet_ntoa(details.raddr.sin_addr);
std::cerr << ": " << ntohs(details.raddr.sin_port);
std::cerr << " type: " << details.type;
std::cerr << std::endl;
#endif
}
#endif // P3CONNMGR_NO_TCP_CONNECTIONS
} /****** STACK UNLOCK MUTEX *******/
/* notify if they say we can, or we cannot connect ! */
if (details.type & RS_NET_CONN_UDP_DHT_SYNC)
{
retryConnectNotify(id);
}
#else
} // P3CONNMGR_NO_AUTO_CONNECTION /****** STACK UNLOCK MUTEX *******/
#endif // P3CONNMGR_NO_AUTO_CONNECTION
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
if (it->second.inConnAttempt)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() ALREADY IN CONNECT ATTEMPT: ";
std::cerr << " id: " << id;
std::cerr << std::endl;
/* -> it'll automatically use the addresses */
std::cerr << "p3ConnectMgr::peerStatus() Resulting Peer State:" << std::endl;
printConnectState(it->second);
std::cerr << std::endl;
#endif
return;
}
/* start a connection attempt */
if (it->second.connAddrs.size() > 0)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() Started CONNECT ATTEMPT! ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
it->second.actions |= RS_PEER_CONNECT_REQ;
mStatusChanged = true;
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() No addr suitable for CONNECT ATTEMPT! ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
}
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerStatus() Resulting Peer State:" << std::endl;
printConnectState(it->second);
std::cerr << std::endl;
#endif
}
void p3ConnectMgr::peerConnectRequest(std::string id, struct sockaddr_in raddr,
uint32_t source)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest()";
std::cerr << " id: " << id;
std::cerr << " raddr: " << inet_ntoa(raddr.sin_addr);
std::cerr << ":" << ntohs(raddr.sin_port);
std::cerr << " source: " << source;
std::cerr << std::endl;
#endif
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::peerConnectRequest()";
out << " id: " << id;
out << " raddr: " << inet_ntoa(raddr.sin_addr);
out << ":" << ntohs(raddr.sin_port);
out << " source: " << source;
rslog(RSL_WARNING, p3connectzone, out.str());
}
/******************** TCP PART *****************************/
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() Try TCP first";
std::cerr << std::endl;
#endif
retryConnectTCP(id);
/******************** UDP PART *****************************/
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
if (ownState.netMode & RS_NET_MODE_UNREACHABLE)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() Unreachable - no UDP connection";
std::cerr << std::endl;
#endif
return;
}
/* look up the id */
std::map<std::string, peerConnectState>::iterator it;
bool isFriend = true;
it = mFriendList.find(id);
if (it == mFriendList.end())
{
/* check Others list */
isFriend = false;
it = mOthersList.find(id);
if (it == mOthersList.end())
{
/* not found - ignore */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() Peer Not Found - Ignore";
std::cerr << std::endl;
#endif
return;
}
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() Peer is in mOthersList - Ignore";
std::cerr << std::endl;
#endif
return;
}
/* if already connected -> done */
if (it->second.state & RS_PEER_S_CONNECTED)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() Already connected - Ignore";
std::cerr << std::endl;
#endif
return;
}
time_t now = time(NULL);
/* this is a UDP connection request (DHT only for the moment!) */
if (isValidNet(&(raddr.sin_addr)))
{
/* add the remote address */
peerConnectAddress pca;
pca.ts = now;
pca.type = RS_NET_CONN_UDP_DHT_SYNC;
pca.delay = 0;
if (source == RS_CB_DHT)
{
pca.period = P3CONNMGR_UDP_DHT_DELAY;
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() source = DHT ";
std::cerr << std::endl;
#endif
}
else if (source == RS_CB_PROXY)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() source = PROXY ";
std::cerr << std::endl;
#endif
pca.period = P3CONNMGR_UDP_PROXY_DELAY;
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() source = UNKNOWN ";
std::cerr << std::endl;
#endif
/* error! */
pca.period = P3CONNMGR_UDP_PROXY_DELAY;
}
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() period = " << pca.period;
std::cerr << std::endl;
#endif
pca.addr = raddr;
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::peerConnectRequest() PushBack UDP Address: ";
out << " id: " << id;
out << " raddr: " << inet_ntoa(pca.addr.sin_addr);
out << ":" << ntohs(pca.addr.sin_port);
out << " type: " << pca.type;
out << " delay: " << pca.delay;
out << " period: " << pca.period;
out << " ts: " << pca.ts;
rslog(RSL_WARNING, p3connectzone, out.str());
}
/* push to the back ... TCP ones should be tried first */
it->second.connAddrs.push_back(pca);
}
if (it->second.inConnAttempt)
{
/* -> it'll automatically use the addresses */
return;
}
/* start a connection attempt */
if (it->second.connAddrs.size() > 0)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() Started CONNECT ATTEMPT! ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
it->second.actions |= RS_PEER_CONNECT_REQ;
mStatusChanged = true;
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::peerConnectRequest() No addr suitable for CONNECT ATTEMPT! ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
}
}
/*******************************************************************/
/*******************************************************************/
bool p3ConnectMgr::addFriend(std::string id, uint32_t netMode, uint32_t visState, time_t lastContact)
{
/* so three possibilities
* (1) already exists as friend -> do nothing.
* (2) is in others list -> move over.
* (3) is non-existant -> create new one.
*/
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::addFriend() " << id;
std::cerr << std::endl;
#endif
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() != mFriendList.find(id))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::addFriend() Already Exists";
std::cerr << std::endl;
#endif
/* (1) already exists */
return true;
}
/* check with the AuthMgr if its authorised */
if (!mAuthMgr->isAuthenticated(id))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::addFriend() Failed Authentication";
std::cerr << std::endl;
#endif
/* no auth */
return false;
}
/* check if it is in others */
if (mOthersList.end() != (it = mOthersList.find(id)))
{
/* (2) in mOthersList -> move over */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::addFriend() Move from Others";
std::cerr << std::endl;
#endif
mFriendList[id] = it->second;
mOthersList.erase(it);
it = mFriendList.find(id);
/* setup state */
it->second.state = RS_PEER_S_FRIEND;
it->second.actions = RS_PEER_NEW;
/* setup connectivity parameters */
it->second.visState = visState;
it->second.netMode = netMode;
it->second.lastcontact = lastContact;
mStatusChanged = true;
/* add peer to DHT (if not dark) */
if (it->second.visState & RS_VIS_STATE_NODHT)
{
/* hidden from DHT world */
netAssistFriend(id, false);
}
else
{
netAssistFriend(id, true);
}
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return true;
}
/* get details from AuthMgr */
pqiAuthDetails detail;
if (!mAuthMgr->getDetails(id, detail))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::addFriend() Failed to get Details";
std::cerr << std::endl;
#endif
/* ERROR: no details */
return false;
}
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::addFriend() Creating New Entry";
std::cerr << std::endl;
#endif
/* create a new entry */
peerConnectState pstate;
pstate.id = id;
pstate.name = detail.name;
pstate.state = RS_PEER_S_FRIEND;
pstate.actions = RS_PEER_NEW;
pstate.visState = visState;
pstate.netMode = netMode;
pstate.lastcontact = lastContact;
/* addr & timestamps -> auto cleared */
mFriendList[id] = pstate;
mStatusChanged = true;
/* expect it to be a standard DHT */
netAssistFriend(id, true);
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return true;
}
bool p3ConnectMgr::removeFriend(std::string id)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::removeFriend() " << id;
std::cerr << std::endl;
#endif
netAssistFriend(id, false);
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* move to othersList */
bool success = false;
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() != (it = mFriendList.find(id)))
{
peerConnectState peer = it->second;
mFriendList.erase(it);
peer.state &= (~RS_PEER_S_FRIEND);
peer.state &= (~RS_PEER_S_CONNECTED);
peer.state &= (~RS_PEER_S_ONLINE);
peer.actions = RS_PEER_MOVED;
peer.inConnAttempt = false;
mOthersList[id] = peer;
mStatusChanged = true;
success = true;
}
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return success;
}
bool p3ConnectMgr::addNeighbour(std::string id)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::addNeighbour() " << id;
std::cerr << std::endl;
#endif
/* so three possibilities
* (1) already exists as friend -> do nothing.
* (2) already in others list -> do nothing.
* (3) is non-existant -> create new one.
*/
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() == mFriendList.find(id))
{
/* (1) already exists */
return false;
}
if (mOthersList.end() == mOthersList.find(id))
{
/* (2) already exists */
return true;
}
/* check with the AuthMgr if its valid */
if (!mAuthMgr->isValid(id))
{
/* no auth */
return false;
}
/* get details from AuthMgr */
pqiAuthDetails detail;
if (!mAuthMgr->getDetails(id, detail))
{
/* no details */
return false;
}
/* create a new entry */
peerConnectState pstate;
pstate.id = id;
pstate.name = detail.name;
pstate.state = 0;
pstate.actions = 0; //RS_PEER_NEW;
pstate.visState = RS_VIS_STATE_STD;
pstate.netMode = RS_NET_MODE_UNKNOWN;
/* addr & timestamps -> auto cleared */
mOthersList[id] = pstate;
return true;
}
/*******************************************************************/
/*******************************************************************/
/*************** External Control ****************/
bool p3ConnectMgr::retryConnect(std::string id)
{
retryConnectTCP(id);
retryConnectNotify(id);
return true;
}
bool p3ConnectMgr::retryConnectTCP(std::string id)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* push addresses onto stack */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP()";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
/* look up the id */
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id)))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Peer is not Friend";
std::cerr << std::endl;
#endif
return false;
}
/* if already connected -> done */
if (it->second.state & RS_PEER_S_CONNECTED)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Peer Already Connected";
std::cerr << std::endl;
#endif
return true;
}
/* are the addresses different? */
time_t now = time(NULL);
std::list<peerConnectAddress>::iterator cit;
/* add in attempts ... local(TCP), remote(TCP)
*/
#ifndef P3CONNMGR_NO_TCP_CONNECTIONS
/* if address is same -> try local */
if ((isValidNet(&(it->second.localaddr.sin_addr))) &&
(sameNet(&(ownState.localaddr.sin_addr),
&(it->second.localaddr.sin_addr))))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Local Address Valid: ";
std::cerr << inet_ntoa(it->second.localaddr.sin_addr);
std::cerr << ":" << ntohs(it->second.localaddr.sin_port);
std::cerr << std::endl;
#endif
bool localExists = false;
if ((it->second.inConnAttempt) &&
(it->second.currentConnAddr.type == RS_NET_CONN_TCP_LOCAL))
{
localExists = true;
}
for(cit = it->second.connAddrs.begin();
(!localExists) && (cit != it->second.connAddrs.begin()); cit++)
{
if (cit->type == RS_NET_CONN_TCP_LOCAL)
{
localExists = true;
}
}
/* check if there is a local one on there already */
if (!localExists)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Adding Local Addr to Queue";
std::cerr << std::endl;
#endif
/* add the local address */
peerConnectAddress pca;
pca.ts = now;
pca.type = RS_NET_CONN_TCP_LOCAL;
pca.addr = it->second.localaddr;
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::retryConnectTCP() PushBack Local TCP Address: ";
out << " id: " << id;
out << " raddr: " << inet_ntoa(pca.addr.sin_addr);
out << ":" << ntohs(pca.addr.sin_port);
out << " type: " << pca.type;
out << " delay: " << pca.delay;
out << " period: " << pca.period;
out << " ts: " << pca.ts;
rslog(RSL_WARNING, p3connectzone, out.str());
}
it->second.connAddrs.push_back(pca);
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Local Addr already in Queue";
std::cerr << std::endl;
#endif
}
}
/* otherwise try external ... (should check flags) */
//if ((isValidNet(&(it->second.serveraddr.sin_addr))) &&
// (it->second.netMode = RS_NET_MODE_EXT))
/* always try external */
if (isValidNet(&(it->second.serveraddr.sin_addr)))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Ext Address Valid: ";
std::cerr << inet_ntoa(it->second.serveraddr.sin_addr);
std::cerr << ":" << ntohs(it->second.serveraddr.sin_port);
std::cerr << std::endl;
#endif
bool remoteExists = false;
if ((it->second.inConnAttempt) &&
(it->second.currentConnAddr.type == RS_NET_CONN_TCP_EXTERNAL))
{
remoteExists = true;
}
for(cit = it->second.connAddrs.begin();
(!remoteExists) && (cit != it->second.connAddrs.begin()); cit++)
{
if (cit->type == RS_NET_CONN_TCP_EXTERNAL)
{
remoteExists = true;
}
}
/* check if there is a local one on there already */
if (!remoteExists)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Adding Ext Addr to Queue";
std::cerr << std::endl;
#endif
/* add the remote address */
peerConnectAddress pca;
pca.ts = now;
pca.type = RS_NET_CONN_TCP_EXTERNAL;
pca.addr = it->second.serveraddr;
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::retryConnectTCP() PushBack Ext TCP Address: ";
out << " id: " << id;
out << " raddr: " << inet_ntoa(pca.addr.sin_addr);
out << ":" << ntohs(pca.addr.sin_port);
out << " type: " << pca.type;
out << " delay: " << pca.delay;
out << " period: " << pca.period;
out << " ts: " << pca.ts;
rslog(RSL_WARNING, p3connectzone, out.str());
}
it->second.connAddrs.push_back(pca);
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Ext Addr already in Queue";
std::cerr << std::endl;
#endif
}
}
#endif // P3CONNMGR_NO_TCP_CONNECTIONS
/* flag as last attempt to prevent loop */
it->second.lastattempt = time(NULL);
if (it->second.inConnAttempt)
{
/* -> it'll automatically use the addresses */
return true;
}
/* start a connection attempt */
if (it->second.connAddrs.size() > 0)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() Started CONNECT ATTEMPT! ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
it->second.actions |= RS_PEER_CONNECT_REQ;
mStatusChanged = true;
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectTCP() No addr suitable for CONNECT ATTEMPT! ";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
}
return true;
}
bool p3ConnectMgr::retryConnectNotify(std::string id)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* push addresses onto stack */
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectNotify()";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
/* look up the id */
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id)))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectNotify() Peer is not Friend";
std::cerr << std::endl;
#endif
return false;
}
/* if already connected -> done */
if (it->second.state & RS_PEER_S_CONNECTED)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectNotify() Peer Already Connected";
std::cerr << std::endl;
#endif
return true;
}
/* flag as last attempt to prevent loop */
it->second.lastattempt = time(NULL);
if (ownState.netMode & RS_NET_MODE_UNREACHABLE)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectNotify() UNREACHABLE so no Notify!";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::retryConnectNotify() Notifying Peer";
std::cerr << " id: " << id;
std::cerr << std::endl;
#endif
{
/* Log */
std::ostringstream out;
out << "p3ConnectMgr::retryConnectNotify() Notifying Peer";
out << " id: " << id;
rslog(RSL_WARNING, p3connectzone, out.str());
}
/* attempt UDP connection */
netAssistNotify(id);
}
return true;
}
bool p3ConnectMgr::setLocalAddress(std::string id, struct sockaddr_in addr)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
if (id == mAuthMgr->OwnId())
{
ownState.localaddr = addr;
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return true;
}
/* check if it is a friend */
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id)))
{
if (mOthersList.end() == (it = mOthersList.find(id)))
{
return false;
}
}
/* "it" points to peer */
it->second.localaddr = addr;
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return true;
}
bool p3ConnectMgr::setExtAddress(std::string id, struct sockaddr_in addr)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
if (id == mAuthMgr->OwnId())
{
ownState.serveraddr = addr;
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return true;
}
/* check if it is a friend */
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id)))
{
if (mOthersList.end() == (it = mOthersList.find(id)))
{
return false;
}
}
/* "it" points to peer */
it->second.serveraddr = addr;
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return true;
}
bool p3ConnectMgr::setNetworkMode(std::string id, uint32_t netMode)
{
if (id == mAuthMgr->OwnId())
{
uint32_t visState = ownState.visState;
setOwnNetConfig(netMode, visState);
return true;
}
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check if it is a friend */
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id)))
{
if (mOthersList.end() == (it = mOthersList.find(id)))
{
return false;
}
}
/* "it" points to peer */
it->second.netMode = netMode;
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return false;
}
bool p3ConnectMgr::setVisState(std::string id, uint32_t visState)
{
if (id == mAuthMgr->OwnId())
{
uint32_t netMode = ownState.netMode;
setOwnNetConfig(netMode, visState);
return true;
}
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
/* check if it is a friend */
std::map<std::string, peerConnectState>::iterator it;
bool isFriend = false;
if (mFriendList.end() == (it = mFriendList.find(id)))
{
if (mOthersList.end() == (it = mOthersList.find(id)))
{
return false;
}
}
else
{
isFriend = true;
}
/* "it" points to peer */
it->second.visState = visState;
if (isFriend)
{
/* toggle DHT state */
if (it->second.visState & RS_VIS_STATE_NODHT)
{
/* hidden from DHT world */
netAssistFriend(id, false);
}
else
{
netAssistFriend(id, true);
}
}
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
return false;
}
/*******************************************************************/
bool p3ConnectMgr::checkNetAddress()
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::checkNetAddress()";
std::cerr << std::endl;
#endif
std::list<std::string> addrs = getLocalInterfaces();
std::list<std::string>::iterator it;
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
bool found = false;
for(it = addrs.begin(); (!found) && (it != addrs.end()); it++)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::checkNetAddress() Local Interface: " << *it;
std::cerr << std::endl;
#endif
// Ive added the 'isNotLoopbackNet' to prevent re-using the lo address if this was saved in the
// configuration. In such a case, lo should only be chosen from getPreferredInterface as a last resort
// fallback solution.
//
if ((!isLoopbackNet(&ownState.localaddr.sin_addr)) && (*it) == inet_ntoa(ownState.localaddr.sin_addr))
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::checkNetAddress() Matches Existing Address! FOUND = true";
std::cerr << std::endl;
#endif
found = true;
}
}
/* check that we didn't catch 0.0.0.0 - if so go for prefered */
if ((found) && (ownState.localaddr.sin_addr.s_addr == 0))
{
found = false;
}
if (!found)
{
ownState.localaddr.sin_addr = getPreferredInterface();
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::checkNetAddress() Local Address Not Found: Using Preferred Interface: ";
std::cerr << inet_ntoa(ownState.localaddr.sin_addr);
std::cerr << std::endl;
#endif
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
}
if ((isPrivateNet(&(ownState.localaddr.sin_addr))) ||
(isLoopbackNet(&(ownState.localaddr.sin_addr))))
{
/* firewalled */
//own_cert -> Firewalled(true);
}
else
{
//own_cert -> Firewalled(false);
}
int port = ntohs(ownState.localaddr.sin_port);
if ((port < PQI_MIN_PORT) || (port > PQI_MAX_PORT))
{
ownState.localaddr.sin_port = htons(PQI_DEFAULT_PORT);
}
/* if localaddr = serveraddr, then ensure that the ports
* are the same (modify server)... this mismatch can
* occur when the local port is changed....
*/
if (ownState.localaddr.sin_addr.s_addr ==
ownState.serveraddr.sin_addr.s_addr)
{
ownState.serveraddr.sin_port =
ownState.localaddr.sin_port;
}
// ensure that address family is set, otherwise windows Barfs.
ownState.localaddr.sin_family = AF_INET;
ownState.serveraddr.sin_family = AF_INET;
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::checkNetAddress() Final Local Address: ";
std::cerr << inet_ntoa(ownState.localaddr.sin_addr);
std::cerr << ":" << ntohs(ownState.localaddr.sin_port);
std::cerr << std::endl;
#endif
return 1;
}
/************************* p3config functions **********************/
/*******************************************************************/
/* Key Functions to be overloaded for Full Configuration */
RsSerialiser *p3ConnectMgr::setupSerialiser()
{
RsSerialiser *rss = new RsSerialiser();
rss->addSerialType(new RsPeerConfigSerialiser());
rss->addSerialType(new RsGeneralConfigSerialiser()) ;
return rss;
}
std::list<RsItem *> p3ConnectMgr::saveList(bool &cleanup)
{
/* create a list of current peers */
std::list<RsItem *> saveData;
cleanup = true;
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
RsPeerNetItem *item = new RsPeerNetItem();
item->clear();
item->pid = getOwnId();
if (ownState.netMode & RS_NET_MODE_TRY_EXT)
{
item->netMode = RS_NET_MODE_EXT;
}
else if (ownState.netMode & RS_NET_MODE_TRY_UPNP)
{
item->netMode = RS_NET_MODE_UPNP;
}
else
{
item->netMode = RS_NET_MODE_UDP;
}
item->visState = ownState.visState;
item->lastContact = ownState.lastcontact;
item->localaddr = ownState.localaddr;
item->remoteaddr = ownState.serveraddr;
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::saveList() Own Config Item:";
std::cerr << std::endl;
item->print(std::cerr, 10);
std::cerr << std::endl;
#endif
saveData.push_back(item);
/* iterate through all friends and save */
std::map<std::string, peerConnectState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{
item = new RsPeerNetItem();
item->clear();
item->pid = it->first;
item->netMode = (it->second).netMode;
item->visState = (it->second).visState;
item->lastContact = (it->second).lastcontact;
item->localaddr = (it->second).localaddr;
item->remoteaddr = (it->second).serveraddr;
saveData.push_back(item);
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::saveList() Peer Config Item:";
std::cerr << std::endl;
item->print(std::cerr, 10);
std::cerr << std::endl;
#endif
}
RsPeerStunItem *sitem = new RsPeerStunItem();
std::list<std::string>::iterator sit;
uint32_t count = 0;
for(sit = mStunList.begin(); (sit != mStunList.end()) &&
(count < RS_STUN_LIST_MIN); sit++, count++)
{
sitem->stunList.ids.push_back(*sit);
}
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::saveList() Peer Stun Item:";
std::cerr << std::endl;
sitem->print(std::cerr, 10);
std::cerr << std::endl;
#endif
saveData.push_back(sitem);
// Now save config for network digging strategies
RsConfigKeyValueSet *vitem = new RsConfigKeyValueSet ;
RsTlvKeyValue kv;
kv.key = "USE_EXTR_IP_FINDER" ;
kv.value = (use_extr_addr_finder)?"TRUE":"FALSE" ;
vitem->tlvkvs.pairs.push_back(kv) ;
std::cout << "Pushing item for use_extr_addr_finder = " << use_extr_addr_finder << std::endl ;
saveData.push_back(vitem);
return saveData;
}
bool p3ConnectMgr::loadList(std::list<RsItem *> load)
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::loadList() Item Count: " << load.size();
std::cerr << std::endl;
#endif
/* load the list of peers */
std::list<RsItem *>::iterator it;
for(it = load.begin(); it != load.end(); it++)
{
RsPeerNetItem *pitem = dynamic_cast<RsPeerNetItem *>(*it);
RsPeerStunItem *sitem = dynamic_cast<RsPeerStunItem *>(*it);
RsConfigKeyValueSet *vitem = dynamic_cast<RsConfigKeyValueSet *>(*it) ;
if (pitem)
{
if (pitem->pid == getOwnId())
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::loadList() Own Config Item:";
std::cerr << std::endl;
pitem->print(std::cerr, 10);
std::cerr << std::endl;
#endif
/* add ownConfig */
setOwnNetConfig(pitem->netMode, pitem->visState);
setLocalAddress(pitem->pid, pitem->localaddr);
setExtAddress(pitem->pid, pitem->remoteaddr);
}
else
{
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::loadList() Peer Config Item:";
std::cerr << std::endl;
pitem->print(std::cerr, 10);
std::cerr << std::endl;
#endif
/* ************* */
addFriend(pitem->pid, pitem->netMode, pitem->visState, pitem->lastContact);
setLocalAddress(pitem->pid, pitem->localaddr);
setExtAddress(pitem->pid, pitem->remoteaddr);
}
}
else if (sitem)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::loadList() Stun Config Item:";
std::cerr << std::endl;
sitem->print(std::cerr, 10);
std::cerr << std::endl;
#endif
std::list<std::string>::iterator sit;
for(sit = sitem->stunList.ids.begin();
sit != sitem->stunList.ids.end(); sit++)
{
mStunList.push_back(*sit);
}
}
else if(vitem)
{
RsStackMutex stack(connMtx); /****** STACK LOCK MUTEX *******/
#ifdef CONN_DEBUG
std::cerr << "p3ConnectMgr::loadList() General Variable Config Item:";
std::cerr << std::endl;
vitem->print(std::cerr, 10);
std::cerr << std::endl;
#endif
if(vitem->tlvkvs.pairs.front().key == "USE_EXTR_IP_FINDER")
{
use_extr_addr_finder = (vitem->tlvkvs.pairs.front().value == "TRUE") ;
std::cerr << "setting use_extr_addr_finder to " << use_extr_addr_finder << std::endl ;
}
}
delete (*it);
}
return true;
}
void printConnectState(peerConnectState &peer)
{
#ifdef CONN_DEBUG
std::cerr << "Friend: " << peer.name;
std::cerr << " Id: " << peer.id;
std::cerr << " State: " << peer.state;
if (peer.state & RS_PEER_S_FRIEND)
std::cerr << " S:RS_PEER_S_FRIEND";
if (peer.state & RS_PEER_S_ONLINE)
std::cerr << " S:RS_PEER_S_ONLINE";
if (peer.state & RS_PEER_S_CONNECTED)
std::cerr << " S:RS_PEER_S_CONNECTED";
std::cerr << " Actions: " << peer.actions;
if (peer.actions & RS_PEER_NEW)
std::cerr << " A:RS_PEER_NEW";
if (peer.actions & RS_PEER_MOVED)
std::cerr << " A:RS_PEER_MOVED";
if (peer.actions & RS_PEER_CONNECTED)
std::cerr << " A:RS_PEER_CONNECTED";
if (peer.actions & RS_PEER_DISCONNECTED)
std::cerr << " A:RS_PEER_DISCONNECTED";
if (peer.actions & RS_PEER_CONNECT_REQ)
std::cerr << " A:RS_PEER_CONNECT_REQ";
std::cerr << std::endl;
#endif
return;
}
bool p3ConnectMgr::addBootstrapStunPeers()
{
std::string id;
struct sockaddr_in dummyaddr;
uint32_t flags = 0;
/* only use the Bootstrap system now */
return true;
}
/************************ INTERFACES ***********************/
void p3ConnectMgr::addNetAssistFirewall(uint32_t id, pqiNetAssistFirewall *fwAgent)
{
mFwAgents[id] = fwAgent;
}
bool p3ConnectMgr::enableNetAssistFirewall(bool on)
{
std::map<uint32_t, pqiNetAssistFirewall *>::iterator it;
for(it = mFwAgents.begin(); it != mFwAgents.end(); it++)
{
(it->second)->enable(on);
}
return true;
}
bool p3ConnectMgr::netAssistFirewallEnabled()
{
std::map<uint32_t, pqiNetAssistFirewall *>::iterator it;
for(it = mFwAgents.begin(); it != mFwAgents.end(); it++)
{
if ((it->second)->getEnabled())
{
return true;
}
}
return false;
}
bool p3ConnectMgr::netAssistFirewallActive()
{
std::map<uint32_t, pqiNetAssistFirewall *>::iterator it;
for(it = mFwAgents.begin(); it != mFwAgents.end(); it++)
{
if ((it->second)->getActive())
{
return true;
}
}
return false;
}
bool p3ConnectMgr::netAssistFirewallShutdown()
{
std::map<uint32_t, pqiNetAssistFirewall *>::iterator it;
for(it = mFwAgents.begin(); it != mFwAgents.end(); it++)
{
(it->second)->shutdown();
}
return true;
}
bool p3ConnectMgr::netAssistFirewallPorts(uint16_t iport, uint16_t eport)
{
std::map<uint32_t, pqiNetAssistFirewall *>::iterator it;
for(it = mFwAgents.begin(); it != mFwAgents.end(); it++)
{
(it->second)->setInternalPort(iport);
(it->second)->setExternalPort(eport);
}
return true;
}
bool p3ConnectMgr::netAssistExtAddress(struct sockaddr_in &extAddr)
{
std::map<uint32_t, pqiNetAssistFirewall *>::iterator it;
for(it = mFwAgents.begin(); it != mFwAgents.end(); it++)
{
if ((it->second)->getActive())
{
if ((it->second)->getExternalAddress(extAddr))
{
return true;
}
}
}
return false;
}
void p3ConnectMgr::addNetAssistConnect(uint32_t id, pqiNetAssistConnect *dht)
{
mDhts[id] = dht;
}
bool p3ConnectMgr::enableNetAssistConnect(bool on)
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
(it->second)->enable(on);
}
return true;
}
bool p3ConnectMgr::netAssistConnectEnabled()
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
if ((it->second)->getEnabled())
{
return true;
}
}
return false;
}
bool p3ConnectMgr::netAssistConnectActive()
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
if ((it->second)->getActive())
{
return true;
}
}
return false;
}
bool p3ConnectMgr::netAssistConnectShutdown()
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
(it->second)->shutdown();
}
return true;
}
bool p3ConnectMgr::netAssistFriend(std::string id, bool on)
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
if (on)
{
(it->second)->findPeer(id);
}
else
{
(it->second)->dropPeer(id);
}
}
return true;
}
bool p3ConnectMgr::netAssistAddStun(std::string id)
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
(it->second)->addStun(id);
}
return true;
}
bool p3ConnectMgr::netAssistStun(bool on)
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
(it->second)->enableStun(on);
}
return true;
}
bool p3ConnectMgr::netAssistNotify(std::string id)
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
(it->second)->notifyPeer(id);
}
return true;
}
bool p3ConnectMgr::netAssistSetAddress( struct sockaddr_in &laddr,
struct sockaddr_in &eaddr,
uint32_t mode)
{
std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
for(it = mDhts.begin(); it != mDhts.end(); it++)
{
(it->second)->setExternalInterface(laddr, eaddr, mode);
}
return true;
}
bool p3ConnectMgr::getUPnPState()
{
return netAssistFirewallActive();
}
bool p3ConnectMgr::getUPnPEnabled()
{
return netAssistFirewallEnabled();
}
bool p3ConnectMgr::getDHTEnabled()
{
return netAssistConnectEnabled();
}
bool p3ConnectMgr::getNetStatusOk()
{
return netFlagOk;
}
bool p3ConnectMgr::getNetStatusUpnpOk()
{
return netFlagUpnpOk;
}
bool p3ConnectMgr::getNetStatusDhtOk()
{
return netFlagDhtOk;
}
bool p3ConnectMgr::getNetStatusExtOk()
{
return netFlagExtOk;
}
bool p3ConnectMgr::getNetStatusUdpOk()
{
return netFlagUdpOk;
}
bool p3ConnectMgr::getNetStatusTcpOk()
{
return netFlagTcpOk;
}
bool p3ConnectMgr::getNetResetReq()
{
return netFlagResetReq;
}
Reference in New Issue View Git Blame Copy Permalink