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

Changes to libretroshare to get it to compile (still missing fns - so won't link yet!)

Browse Source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-netupgrade@4419 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2011-07-10 00:41:39 +00:00
parent 6eb27c9a1a
commit bbd11e69c1
17 changed files with 924 additions and 4726 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libretroshare/src/libretroshare.pro
View File

@ -66,7 +66,9 @@ bitdht {
HEADERS += dht/p3bitdht.h
SOURCES += dht/p3bitdht.cc \
dht/p3bitdht_interface.cc
dht/p3bitdht_interface.cc \
dht/p3bitdht_peers.cc \
dht/p3bitdht_peernet.cc
HEADERS += tcponudp/udppeer.h \
tcponudp/bio_tou.h \

8
libretroshare/src/plugins/pluginmanager.cc
View File

@ -28,7 +28,7 @@ std::string RsPluginManager::_remote_cache_dir ;
std::vector<std::string> RsPluginManager::_plugin_directories ;
ftServer *RsPluginManager::_ftserver = NULL ;
p3ConnectMgr *RsPluginManager::_connectmgr = NULL ;
p3LinkMgr *RsPluginManager::_linkmgr = NULL ;
typedef RsPlugin *(*RetroSharePluginEntry)(void) ;
RsPluginHandler *rsPlugins ;
@ -215,10 +215,10 @@ bool RsPluginManager::loadPlugin(const std::string& plugin_name)
}
}
p3ConnectMgr *RsPluginManager::getConnectMgr() const
p3LinkMgr *RsPluginManager::getLinkMgr() const
{
assert(_connectmgr != NULL) ;
return _connectmgr ;
assert(_linkmgr != NULL) ;
return _linkmgr ;
}
ftServer *RsPluginManager::getFileServer() const
{

8
libretroshare/src/plugins/pluginmanager.h
View File

@ -8,7 +8,7 @@
class p3ConfigMgr ;
class p3ServiceServer ;
class p3ConnectMgr ;
class p3LinkMgr ;
struct PluginInfo
{
@ -38,7 +38,7 @@ class RsPluginManager: public RsPluginHandler, public p3Config
virtual const std::string& getLocalCacheDir() const ;
virtual const std::string& getRemoteCacheDir() const ;
virtual ftServer *getFileServer() const ;
virtual p3ConnectMgr *getConnectMgr() const ;
virtual p3LinkMgr *getLinkMgr() const ;
// ---------------- Derived from p3Config -------------------//
//
@ -55,7 +55,7 @@ class RsPluginManager: public RsPluginHandler, public p3Config
static bool acceptablePluginName(const std::string& s) ;
static void setCacheDirectories(const std::string& local,const std::string& remote) ;
static void setFileServer(ftServer *ft) { _ftserver = ft ; }
static void setConnectMgr(p3ConnectMgr *cm) { _connectmgr = cm ; }
static void setLinkMgr(p3LinkMgr *cm) { _linkmgr = cm ; }
void loadPlugins(const std::vector<std::string>& plugin_directories) ;
@ -72,7 +72,7 @@ class RsPluginManager: public RsPluginHandler, public p3Config
static std::string _remote_cache_dir ;
static std::string _local_cache_dir ;
static ftServer *_ftserver ;
static p3ConnectMgr *_connectmgr ;
static p3LinkMgr *_linkmgr ;
static std::vector<std::string> _plugin_directories ;
};

4180
libretroshare/src/pqi/p3connmgr.cc
View File

File diff suppressed because it is too large Load Diff

454
libretroshare/src/pqi/p3connmgr.h
View File

@ -1,454 +0,0 @@
/*
* libretroshare/src/pqi: p3connmgr.h
*
* 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".
*
*/
#ifndef MRK_PQI_CONNECTION_MANAGER_HEADER
#define MRK_PQI_CONNECTION_MANAGER_HEADER
#include "pqi/pqimonitor.h"
#include "pqi/pqiipset.h"
//#include "pqi/p3dhtmgr.h"
//#include "pqi/p3upnpmgr.h"
#include "pqi/pqiassist.h"
#include "pqi/p3cfgmgr.h"
#include "util/rsthreads.h"
class ExtAddrFinder ;
class DNSResolver ;
/* RS_VIS_STATE_XXXX
* determines how public this peer wants to be...
*
* STD = advertise to Peers / DHT checking etc
* GRAY = share with friends / but not DHT
* DARK = hidden from all
* BROWN? = hidden from friends / but on DHT
*/
const uint32_t RS_VIS_STATE_NODISC = 0x0001;
const uint32_t RS_VIS_STATE_NODHT = 0x0002;
const uint32_t RS_VIS_STATE_STD = 0x0000;
const uint32_t RS_VIS_STATE_GRAY = RS_VIS_STATE_NODHT;
const uint32_t RS_VIS_STATE_DARK = RS_VIS_STATE_NODISC | RS_VIS_STATE_NODHT;
const uint32_t RS_VIS_STATE_BROWN = RS_VIS_STATE_NODISC;
/* Startup Modes (confirmed later) */
const uint32_t RS_NET_MODE_TRYMODE = 0x00f0;
const uint32_t RS_NET_MODE_TRY_EXT = 0x0010;
const uint32_t RS_NET_MODE_TRY_UPNP = 0x0020;
const uint32_t RS_NET_MODE_TRY_UDP = 0x0040;
/* Actual State */
const uint32_t RS_NET_MODE_ACTUAL = 0x000f;
const uint32_t RS_NET_MODE_UNKNOWN = 0x0000;
const uint32_t RS_NET_MODE_EXT = 0x0001;
const uint32_t RS_NET_MODE_UPNP = 0x0002;
const uint32_t RS_NET_MODE_UDP = 0x0004;
const uint32_t RS_NET_MODE_UNREACHABLE = 0x0008;
/* order of attempts ... */
const uint32_t RS_NET_CONN_TCP_ALL = 0x000f;
const uint32_t RS_NET_CONN_UDP_ALL = 0x00f0;
const uint32_t RS_NET_CONN_TUNNEL = 0x0f00;
const uint32_t RS_NET_CONN_TCP_LOCAL = 0x0001;
const uint32_t RS_NET_CONN_TCP_EXTERNAL = 0x0002;
const uint32_t RS_NET_CONN_TCP_UNKNOW_TOPOLOGY = 0x0004;
const uint32_t RS_NET_CONN_UDP_DHT_SYNC = 0x0010;
const uint32_t RS_NET_CONN_UDP_PEER_SYNC = 0x0020; /* coming soon */
/* extra flags */
// not sure if needed yet.
//const uint32_t RS_NET_CONN_PEERAGE = 0x0f00;
//const uint32_t RS_NET_CONN_SERVER = 0x0100; /* TCP only */
//const uint32_t RS_NET_CONN_PEER = 0x0200; /* all UDP */
/* flags of peerStatus */
const uint32_t RS_NET_FLAGS_USE_DISC = 0x0001;
const uint32_t RS_NET_FLAGS_USE_DHT = 0x0002;
const uint32_t RS_NET_FLAGS_ONLINE = 0x0004;
const uint32_t RS_NET_FLAGS_EXTERNAL_ADDR = 0x0008;
const uint32_t RS_NET_FLAGS_STABLE_UDP = 0x0010;
const uint32_t RS_NET_FLAGS_TRUSTS_ME = 0x0020;
const uint32_t RS_TCP_STD_TIMEOUT_PERIOD = 5; /* 5 seconds! */
class peerAddrInfo
{
public:
peerAddrInfo(); /* init */
bool found;
uint32_t type;
pqiIpAddrSet addrs;
time_t ts;
};
class peerConnectAddress
{
public:
peerConnectAddress(); /* init */
struct sockaddr_in addr;
uint32_t delay; /* to stop simultaneous connects */
uint32_t period; /* UDP only */
uint32_t type;
time_t ts;
};
class peerConnectState
{
public:
peerConnectState(); /* init */
std::string id;
std::string gpg_id;
uint32_t netMode; /* EXT / UPNP / UDP / INVALID */
uint32_t visState; /* STD, GRAY, DARK */
struct sockaddr_in localaddr, serveraddr;
//used to store current ip (for config and connection management)
struct sockaddr_in currentlocaladdr; /* Mandatory */
struct sockaddr_in currentserveraddr; /* Mandatory */
std::string dyndns;
time_t lastcontact;
/* list of addresses from various sources */
pqiIpAddrSet ipAddrs;
/***** Below here not stored permanently *****/
uint32_t connecttype; // RS_NET_CONN_TCP_ALL / RS_NET_CONN_UDP_ALL
time_t lastavailable;
time_t lastattempt;
std::string name;
std::string location;
uint32_t state;
uint32_t actions;
uint32_t source; /* most current source */
peerAddrInfo dht;
peerAddrInfo disc;
peerAddrInfo peer;
/* a list of connect attempts to make (in order) */
bool inConnAttempt;
peerConnectAddress currentConnAddrAttempt;
std::list<peerConnectAddress> connAddrs;
};
class pqiNetStatus
{
public:
pqiNetStatus();
bool mLocalAddrOk; // Local address is not loopback.
bool mExtAddrOk; // have external address.
bool mExtAddrStableOk; // stable external address.
bool mUpnpOk; // upnp is ok.
bool mDhtOk; // dht is ok.
uint32_t mDhtNetworkSize;
uint32_t mDhtRsNetworkSize;
struct sockaddr_in mLocalAddr; // percieved ext addr.
struct sockaddr_in mExtAddr; // percieved ext addr.
bool mResetReq; // Not Used yet!.
void print(std::ostream &out);
bool NetOk() // minimum to believe network is okay.`
{
return (mLocalAddrOk && mExtAddrOk);
}
};
class p3tunnel;
class RsPeerGroupItem;
class RsGroupInfo;
std::string textPeerConnectState(peerConnectState &state);
class p3ConnectMgr: public pqiConnectCb, public p3Config
{
public:
p3ConnectMgr();
void tick();
/*************** Setup ***************************/
void addNetAssistConnect(uint32_t type, pqiNetAssistConnect *);
void addNetAssistFirewall(uint32_t type, pqiNetAssistFirewall *);
void addNetListener(pqiNetListener *listener);
bool checkNetAddress(); /* check our address is sensible */
/*************** External Control ****************/
bool shutdown(); /* blocking shutdown call */
bool retryConnect(const std::string &id);
bool getUPnPState();
bool getUPnPEnabled();
bool getDHTEnabled();
bool getDHTStats(uint32_t &netsize, uint32_t &localnetsize);
bool getIPServersEnabled();
void setIPServersEnabled(bool b) ;
void getIPServersList(std::list<std::string>& ip_servers) ;
void setTunnelConnection(bool b);
bool getTunnelConnection();
bool getNetStatusLocalOk();
bool getNetStatusUpnpOk();
bool getNetStatusDhtOk();
bool getNetStatusStunOk();
bool getNetStatusExtraAddressCheckOk();
bool getUpnpExtAddress(struct sockaddr_in &addr);
bool getExtFinderAddress(struct sockaddr_in &addr);
void getNetStatus(pqiNetStatus &status);
void setOwnNetConfig(uint32_t netMode, uint32_t visState);
bool setLocalAddress(const std::string &id, struct sockaddr_in addr);
bool setExtAddress(const std::string &id, struct sockaddr_in addr);
bool setDynDNS(const std::string &id, const std::string &dyndns);
bool updateAddressList(const std::string& id, const pqiIpAddrSet &addrs);
bool setNetworkMode(const std::string &id, uint32_t netMode);
bool setVisState(const std::string &id, uint32_t visState);
bool setLocation(const std::string &pid, const std::string &location);//location is shown in the gui to differentiate ssl certs
/* add/remove friends */
bool addFriend(const std::string &ssl_id, const std::string &gpg_id, uint32_t netMode = RS_NET_MODE_UDP,
uint32_t visState = RS_VIS_STATE_STD , time_t lastContact = 0);
bool removeFriend(const std::string &ssl_id);
bool addNeighbour(const std::string&);
/*************** External Control ****************/
/* access to network details (called through Monitor) */
const std::string getOwnId();
bool getOwnNetStatus(peerConnectState &state);
bool isFriend(const std::string &ssl_id);
bool isOnline(const std::string &ssl_id);
bool getFriendNetStatus(const std::string &id, peerConnectState &state);
bool getOthersNetStatus(const std::string &id, peerConnectState &state);
void getOnlineList(std::list<std::string> &ssl_peers);
void getFriendList(std::list<std::string> &ssl_peers);
//void getOthersList(std::list<std::string> &peers); /deprecated
bool getPeerCount (unsigned int *pnFriendCount, unsigned int *pnOnlineCount, bool ssl);
/**************** handle monitors *****************/
void addMonitor(pqiMonitor *mon);
void removeMonitor(pqiMonitor *mon);
/******* overloaded from pqiConnectCb *************/
virtual void peerStatus(std::string id, const pqiIpAddrSet &addrs,
uint32_t type, uint32_t flags, uint32_t source);
virtual void peerConnectRequest(std::string id,
struct sockaddr_in raddr, uint32_t source);
//virtual void stunStatus(std::string id, struct sockaddr_in raddr, uint32_t type, uint32_t flags);
/****************** Connections *******************/
bool connectAttempt(const std::string &id, struct sockaddr_in &addr,
uint32_t &delay, uint32_t &period, uint32_t &type);
bool connectResult(const std::string &id, bool success, uint32_t flags, struct sockaddr_in remote_peer_address);
/******************** Groups **********************/
bool addGroup(RsGroupInfo &groupInfo);
bool editGroup(const std::string &groupId, RsGroupInfo &groupInfo);
bool removeGroup(const std::string &groupId);
bool getGroupInfo(const std::string &groupId, RsGroupInfo &groupInfo);
bool getGroupInfoList(std::list<RsGroupInfo> &groupInfoList);
bool assignPeersToGroup(const std::string &groupId, const std::list<std::string> &peerIds, bool assign);
protected:
/****************** Internal Interface *******************/
virtual bool enableNetAssistFirewall(bool on);
virtual bool netAssistFirewallEnabled();
virtual bool netAssistFirewallActive();
virtual bool netAssistFirewallShutdown();
virtual bool enableNetAssistConnect(bool on);
virtual bool netAssistConnectEnabled();
virtual bool netAssistConnectActive();
virtual bool netAssistConnectShutdown();
virtual bool netAssistConnectStats(uint32_t &netsize, uint32_t &localnetsize);
/* Assist Firewall */
bool netAssistExtAddress(struct sockaddr_in &extAddr);
bool netAssistFirewallPorts(uint16_t iport, uint16_t eport);
/* Assist Connect */
virtual bool netAssistFriend(std::string id, bool on);
virtual bool netAssistSetAddress( struct sockaddr_in &laddr,
struct sockaddr_in &eaddr,
uint32_t mode);
/* Internal Functions */
void netReset();
void statusTick();
void netTick();
void netStartup();
/* startup the bits */
void netDhtInit();
void netUdpInit();
void netStunInit();
void netInit();
void netExtInit();
void netExtCheck();
void netUpnpInit();
void netUpnpCheck();
void netUnreachableCheck();
void networkConsistencyCheck();
/* monitor control */
void tickMonitors();
/* connect attempts UDP */
bool retryConnectUDP(const std::string &id, struct sockaddr_in &rUdpAddr);
/* connect attempts TCP */
bool retryConnectTCP(const std::string &id);
void locked_ConnectAttempt_CurrentAddresses(peerConnectState *peer);
void locked_ConnectAttempt_HistoricalAddresses(peerConnectState *peer);
void locked_ConnectAttempt_AddDynDNS(peerConnectState *peer);
void locked_ConnectAttempt_AddTunnel(peerConnectState *peer);
bool locked_ConnectAttempt_Complete(peerConnectState *peer);
bool locked_CheckPotentialAddr(struct sockaddr_in *addr, time_t age);
bool addAddressIfUnique(std::list<peerConnectAddress> &addrList,
peerConnectAddress &pca);
protected:
/*****************************************************************/
/*********************** p3config ******************************/
/* Key Functions to be overloaded for Full Configuration */
virtual RsSerialiser *setupSerialiser();
virtual bool saveList(bool &cleanup, std::list<RsItem *>&);
virtual void saveDone();
virtual bool loadList(std::list<RsItem *>& load);
/*****************************************************************/
//void setupOwnNetConfig(RsPeerConfigItem *item);
//void addPeer(RsPeerConfigItem *item);
private:
// These should have there own Mutex Protection,
//p3tunnel *mP3tunnel;
ExtAddrFinder *mExtAddrFinder ;
DNSResolver *mDNSResolver ;
/* These are considered static from a MUTEX perspective */
std::map<uint32_t, pqiNetAssistFirewall *> mFwAgents;
std::map<uint32_t, pqiNetAssistConnect *> mDhts;
std::list<pqiNetListener *> mNetListeners;
RsMutex connMtx; /* protects below */
void netStatusReset_locked();
uint32_t mRetryPeriod;
time_t mNetInitTS;
uint32_t mNetStatus;
bool mStatusChanged;
std::list<pqiMonitor *> clients;
bool mUseExtAddrFinder;
bool mAllowTunnelConnection;
/* external Address determination */
//bool mUpnpAddrValid, mStunAddrValid;
//struct sockaddr_in mUpnpExtAddr;
/* network status flags (read by rsiface) */
pqiNetStatus mNetFlags;
pqiNetStatus mOldNetFlags;
peerConnectState mOwnState;
std::map<std::string, peerConnectState> mFriendList;
std::map<std::string, peerConnectState> mOthersList;
std::list<RsPeerGroupItem *> groupList;
uint32_t lastGroupId;
std::list<RsItem *> saveCleanupList; /* TEMPORARY LIST WHEN SAVING */
/* relatively static list of banned ip addresses */
std::list<struct in_addr> mBannedIpList;
};
#endif // MRK_PQI_CONNECTION_MANAGER_HEADER

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

@ -134,13 +134,6 @@ p3LinkMgr::p3LinkMgr(p3PeerMgr *peerMgr, p3NetMgr *netMgr)
{
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
/* setup basics of own state */
mOwnState.id = AuthSSL::getAuthSSL()->OwnId();
mOwnState.name = AuthGPG::getAuthGPG()->getGPGOwnName();
// user decided.
//mOwnState.netMode |= RS_NET_MODE_TRY_UPNP;
mAllowTunnelConnection = false;
mDNSResolver = new DNSResolver();
@ -236,9 +229,43 @@ int p3LinkMgr::getOnlineCount()
}
void p3LinkMgr::setFriendVisibility(const std::string &id, bool isVisible)
{
/* set visibility */
{
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
int count = 0;
std::map<std::string, peerConnectState>::iterator it;
it = mFriendList.find(id);
if (it == mFriendList.end())
{
/* */
std::cerr << "p3LinkMgr::setFriendVisibility() ERROR peer unknown: " << id;
std::cerr << std::endl;
return;
}
if (it->second.dhtVisible == isVisible)
{
/* no change in state */
return;
}
it->second.dhtVisible = isVisible;
if (it->second.state & RS_PEER_S_CONNECTED)
{
/* dont worry about it */
return;
}
}
/* switch the NetAssistOn/Off */
mNetMgr->netAssistFriend(id, isVisible);
}
void p3LinkMgr::tick()
{
@ -1176,7 +1203,7 @@ bool p3LinkMgr::retryConnectTCP(const std::string &id)
pqiIpAddrSet histAddrs;
std::string dyndns;
if (mPeerMgr->setConnectAddresses(id, lAddr, eAddr, histAddrs, dyndns))
if (mPeerMgr->getConnectAddresses(id, lAddr, eAddr, histAddrs, dyndns))
{
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
@ -1539,4 +1566,57 @@ bool p3LinkMgr::locked_ConnectAttempt_Complete(peerConnectState *peer)
}
/***********************************************************************************************************
************************************* Handling of Friends *************************************************
***********************************************************************************************************/
int p3LinkMgr::addFriend(const std::string &id, bool isVisible)
{
{
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it;
it = mFriendList.find(id);
if (it != mFriendList.end())
{
std::cerr << "p3LinkMgr::addFriend() ERROR, friend already exists : " << id;
std::cerr << std::endl;
return 0;
}
peerConnectState pcs;
pcs.dhtVisible = isVisible;
mFriendList[id] = pcs;
}
mNetMgr->netAssistFriend(id, isVisible);
return 1;
}
int p3LinkMgr::removeFriend(const std::string &id)
{
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it;
it = mFriendList.find(id);
if (it == mFriendList.end())
{
std::cerr << "p3LinkMgr::removeFriend() ERROR, friend not there : " << id;
std::cerr << std::endl;
return 0;
}
mFriendList.erase(it);
return 1;
}

11
libretroshare/src/pqi/p3linkmgr.h
View File

@ -106,6 +106,8 @@ class peerConnectState
/***** Below here not stored permanently *****/
bool dhtVisible;
time_t lastcontact;
uint32_t connecttype; // RS_NET_CONN_TCP_ALL / RS_NET_CONN_UDP_ALL
@ -166,6 +168,8 @@ bool retryConnect(const std::string &id);
void setTunnelConnection(bool b);
bool getTunnelConnection();
void setFriendVisibility(const std::string &id, bool isVisible);
//void setOwnNetConfig(uint32_t netMode, uint32_t visState);
//bool setLocalAddress(const std::string &id, struct sockaddr_in addr);
//bool setExtAddress(const std::string &id, struct sockaddr_in addr);
@ -178,11 +182,8 @@ bool getTunnelConnection();
//bool setLocation(const std::string &pid, const std::string &location);//location is shown in the gui to differentiate ssl certs
/* add/remove friends */
bool addFriend(const std::string &ssl_id);
//, const std::string &gpg_id, uint32_t netMode = RS_NET_MODE_UDP,
// uint32_t visState = RS_VIS_STATE_STD , time_t lastContact = 0);
bool removeFriend(const std::string &ssl_id);
int addFriend(const std::string &ssl_id, bool isVisible);
int removeFriend(const std::string &ssl_id);
/*************** External Control ****************/

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

@ -141,15 +141,15 @@ void p3NetMgr::setManagers(p3PeerMgr *peerMgr, p3LinkMgr *linkMgr)
mLinkMgr = linkMgr;
}
void p3NetMgr::setDhtMgr(p3DhtMgr *dhtMgr)
{
mDhtMgr = dhtMgr;
}
//void p3NetMgr::setDhtMgr(p3DhtMgr *dhtMgr)
//{
// mDhtMgr = dhtMgr;
//}
void p3NetMgr::setStunners(p3Stunner *dhtStunner, p3Stunner *proxyStunner)
void p3NetMgr::setAddrAssist(pqiAddrAssist *dhtStun, pqiAddrAssist *proxyStun)
{
mDhtStunner = dhtStunner;
mProxyStunner = proxyStunner;
mDhtStunner = dhtStun;
mProxyStunner = proxyStun;
}
@ -899,7 +899,7 @@ bool p3NetMgr::checkNetAddress()
std::cerr << std::endl;
#endif
mPeerMgr->UpdateOwnAddress(mLocalAddr, mExtAddr);
//mPeerMgr->UpdateOwnAddress(mLocalAddr, mExtAddr);
netReset();
}

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

@ -50,6 +50,7 @@ class DNSResolver ;
*/
class pqiNetStatus
{
public:
@ -94,6 +95,7 @@ class p3NetMgr
p3NetMgr();
void setManagers(p3PeerMgr *peerMgr, p3LinkMgr *linkMgr);
void setAddrAssist(pqiAddrAssist *dhtStun, pqiAddrAssist *proxyStun);
void tick();
@ -108,6 +110,16 @@ bool checkNetAddress(); /* check our address is sensible */
/*************** External Control ****************/
bool shutdown(); /* blocking shutdown call */
/* a nice simple network configuration */
uint32_t getNetStateMode();
uint32_t getNetworkMode();
uint32_t getNatTypeMode();
uint32_t getNatHoleMode();
uint32_t getConnectModes();
bool getUPnPState();
bool getUPnPEnabled();
bool getDHTEnabled();
@ -133,6 +145,9 @@ bool setExtAddress(struct sockaddr_in addr);
bool setNetworkMode(uint32_t netMode);
bool setVisState(uint32_t visState);
virtual bool netAssistFriend(std::string id, bool on);
/*************** External Control ****************/
/* access to network details (called through Monitor) */
@ -156,7 +171,7 @@ bool netAssistExtAddress(struct sockaddr_in &extAddr);
bool netAssistFirewallPorts(uint16_t iport, uint16_t eport);
/* Assist Connect */
virtual bool netAssistFriend(std::string id, bool on);
//virtual bool netAssistFriend(std::string id, bool on);
virtual bool netAssistSetAddress( struct sockaddr_in &laddr,
struct sockaddr_in &eaddr,
uint32_t mode);
@ -202,18 +217,9 @@ private:
p3PeerMgr *mPeerMgr;
p3LinkMgr *mLinkMgr;
/* UDP Stack - managed here */
rsUdpStack *mDhtStack;
UdpStunner *mDhtStunner;
p3BitDht *mBitDht;
UdpRelayReceiver *mRelay;
// No Pointer to UdpPeerReceiver.
// 2ND Stack.
rsUdpStack *mProxyStack;
UdpStunner *mProxyStunner;
// No Pointer to UdpPeerReceiver.
//p3BitDht *mBitDht;
pqiAddrAssist *mDhtStunner;
pqiAddrAssist *mProxyStunner;
RsMutex mNetMtx; /* protects below */

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

@ -152,7 +152,7 @@ void p3PeerMgr::setOwnNetworkMode(uint32_t netMode)
}
// Pass on Flags to NetMgr.
mNetMgr->setOwnNetworkMode((netMode & RS_NET_MODE_ACTUAL));
mNetMgr->setNetworkMode((netMode & RS_NET_MODE_ACTUAL));
}
void p3PeerMgr::setOwnVisState(uint32_t visState)
@ -173,7 +173,7 @@ void p3PeerMgr::setOwnVisState(uint32_t visState)
}
// Pass on Flags to NetMgr.
mNetMgr->setOwnVisState(visState);
mNetMgr->setVisState(visState);
}
@ -296,6 +296,32 @@ void p3PeerMgr::getOthersList(std::list<std::string> &peers)
int p3PeerMgr::getConnectAddresses(const std::string &id,
struct sockaddr_in &lAddr, struct sockaddr_in &eAddr,
pqiIpAddrSet &histAddrs, std::string &dyndns)
{
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerState>::iterator it;
it = mFriendList.find(id);
if (it == mFriendList.end())
{
/* ERROR */
std::cerr << "p3PeerMgr::getConnectAddresses() ERROR unknown Peer";
std::cerr << std::endl;
return 0;
}
lAddr = it->second.localaddr;
eAddr = it->second.serveraddr;
histAddrs = it->second.ipAddrs;
dyndns = it->second.dyndns;
return 1;
}
/****************************
* Update state,
* trigger retry if necessary,
@ -414,7 +440,7 @@ bool p3PeerMgr::addFriend(const std::string &id, const std::string &gpg_id, uint
if (notifyLinkMgr)
{
mLinkMgr->addFriend(id, gpg_id, netMode, visState, lastContact);
mLinkMgr->addFriend(id, !(visState & RS_VIS_STATE_NODHT));
}
return true;

3
libretroshare/src/pqi/p3peermgr.h
View File

@ -163,6 +163,9 @@ void getFriendList(std::list<std::string> &ssl_peers);
//void getOthersList(std::list<std::string> &peers); /deprecated
bool getPeerCount (unsigned int *pnFriendCount, unsigned int *pnOnlineCount, bool ssl);
int getConnectAddresses(const std::string &id,
struct sockaddr_in &lAddr, struct sockaddr_in &eAddr,
pqiIpAddrSet &histAddrs, std::string &dyndns);
/**************** handle monitors *****************/
void addMonitor(pqiMonitor *mon);

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

@ -79,6 +79,22 @@ virtual bool getExternalAddress(struct sockaddr_in &addr) = 0;
};
/* this is for the Stunners
*
*
*/
class pqiAddrAssist
{
public:
pqiAddrAssist() { return; }
virtual ~pqiAddrAssist() { return; }
virtual bool getExternalAddr(struct sockaddr_in &remote, uint8_t &stable) = 0;
};
class pqiNetAssistConnect: public pqiNetAssist

525
libretroshare/src/pqi/pqinetstatebox.cc Normal file
View File

@ -0,0 +1,525 @@
#include "util/rsnet.h"
#include "pqi/pqinetstatebox.h"
#include "time.h"
// External Interface.
void pqiNetStateBox::setAddressStunDht(struct sockaddr_in *addr, bool stable)
{
if ((!mStunDhtSet) || (mStunDhtStable != stable) ||
(addr->sin_addr.s_addr != mStunDhtAddr.sin_addr.s_addr) ||
(addr->sin_port != mStunDhtAddr.sin_port))
{
mStunDhtSet = true;
mStunDhtStable = stable;
mStunDhtAddr = *addr;
mStatusOkay = false;
}
mStunDhtTS = time(NULL);
}
void pqiNetStateBox::setAddressStunProxy(struct sockaddr_in *addr, bool stable)
{
if ((!mStunProxySet) || (mStunProxyStable != stable) ||
(addr->sin_addr.s_addr != mStunProxyAddr.sin_addr.s_addr) ||
(addr->sin_port != mStunProxyAddr.sin_port))
{
mStunProxySet = true;
mStunProxyStable = stable;
mStunProxyAddr = *addr;
mStatusOkay = false;
}
mStunProxyTS = time(NULL);
}
void pqiNetStateBox::setAddressUPnP(bool active, struct sockaddr_in *addr)
{
if ((!mUPnPSet) || (mUPnPActive != active) ||
(addr->sin_addr.s_addr != mUPnPAddr.sin_addr.s_addr) ||
(addr->sin_port != mUPnPAddr.sin_port))
{
mUPnPSet = true;
mUPnPAddr = *addr;
mUPnPActive = active;
mStatusOkay = false;
}
mUPnPTS = time(NULL);
}
void pqiNetStateBox::setAddressNatPMP(bool active, struct sockaddr_in *addr)
{
if ((!mNatPMPSet) || (mNatPMPActive != active) ||
(addr->sin_addr.s_addr != mNatPMPAddr.sin_addr.s_addr) ||
(addr->sin_port != mNatPMPAddr.sin_port))
{
mNatPMPSet = true;
mNatPMPAddr = *addr;
mNatPMPActive = active;
mStatusOkay = false;
}
mNatPMPTS = time(NULL);
}
void pqiNetStateBox::setAddressWebIP(bool active, struct sockaddr_in *addr)
{
if ((!mWebIPSet) || (mWebIPActive != active) ||
(addr->sin_addr.s_addr != mWebIPAddr.sin_addr.s_addr) ||
(addr->sin_port != mWebIPAddr.sin_port))
{
mWebIPSet = true;
mWebIPAddr = *addr;
mWebIPActive = active;
mStatusOkay = false;
}
mWebIPTS = time(NULL);
}
void pqiNetStateBox::setDhtState(bool on, bool active)
{
if ((!mDhtSet) || (mDhtActive != active) || (mDhtOn != on))
{
mDhtSet = true;
mDhtActive = active;
mDhtOn = on;
mStatusOkay = false;
}
mDhtTS = time(NULL);
}
/* Extract Net State */
uint32_t pqiNetStateBox::getNetworkMode()
{
updateNetState();
return mNetworkMode;
}
uint32_t pqiNetStateBox::getNatTypeMode()
{
updateNetState();
return mNatTypeMode;
}
uint32_t pqiNetStateBox::getNatHoleMode()
{
updateNetState();
return mNatHoleMode;
}
uint32_t pqiNetStateBox::getConnectModes()
{
updateNetState();
return mConnectModes;
}
uint32_t pqiNetStateBox::getNetStateMode()
{
updateNetState();
return mNetStateMode;
}
/******************************** Internal Workings *******************************/
pqiNetStateBox::pqiNetStateBox()
{
mStatusOkay = false;
//time_t mStatusTS;
mNetworkMode = PNSB_NETWORK_UNKNOWN;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_UNKNOWN;
mConnectModes = PNSB_CONNECT_NONE;
mNetStateMode = PNSB_NETSTATE_BAD_UNKNOWN;
/* Parameters set externally */
mStunDhtSet = false;
time_t mStunDhtTS = 0;
bool mStunDhtStable = false;
//struct sockaddr_in mStunDhtAddr;
mStunProxySet = false;
time_t mStunProxyTS = 0;
bool mStunProxyStable = false;
//struct sockaddr_in mStunProxyAddr;
mUPnPSet = false;
mUPnPActive = false;
//struct sockaddr_in mUPnPAddr;
mNatPMPSet = false;
mNatPMPActive = false;
//struct sockaddr_in mNatPMPAddr;
mWebIPSet = false;
mWebIPActive = false;
//struct sockaddr_in mWebIPAddr;
mPortForwardedSet = false;
mPortForwarded = 0;
mDhtSet = false;
mDhtActive = false;
mDhtOn = false;
}
#define NETSTATE_PARAM_TIMEOUT 600
#define NETSTATE_TIMEOUT 60
/* check/update Net State */
int pqiNetStateBox::statusOkay()
{
if (!mStatusOkay)
{
return 0;
}
time_t now = time(NULL);
if (now - mStatusTS > NETSTATE_TIMEOUT)
{
return 0;
}
return 1;
}
int pqiNetStateBox::updateNetState()
{
if (!statusOkay())
{
determineNetworkState();
}
return 1;
}
void pqiNetStateBox::clearOldNetworkData()
{
/* check if any measurements are too old to consider */
time_t now = time(NULL);
if (now - mStunProxyTS > NETSTATE_PARAM_TIMEOUT)
{
mStunProxySet = false;
}
if (now - mStunDhtTS > NETSTATE_PARAM_TIMEOUT)
{
mStunDhtSet = false;
}
}
void pqiNetStateBox::determineNetworkState()
{
clearOldNetworkData();
time_t now = time(NULL);
/* now we use the remaining valid input to determine network state */
/* Most important Factor is whether we have DHT(STUN) info to ID connection */
if (mDhtActive)
{
/* firstly lets try to identify OFFLINE / UNKNOWN */
if ((!mStunProxySet) || (!mStunDhtSet))
{
mNetworkMode = PNSB_NETWORK_UNKNOWN;
// Assume these.
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_BAD_UNKNOWN;
//mExtAddress = .... unknown;
//mExtAddrStable = false;
}
else // Both Are Set!
{
if (!mStunDhtStable)
{
//mExtAddress = mStunDhtExtAddress;
//mExtAddrStable = false;
if (!mStunProxyStable)
{
/* both unstable, Symmetric NAT, Firewalled, No UDP Hole */
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_SYMMETRIC;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_BAD_NATSYM;
}
else
{
/* if DhtStun Unstable, but ProxyStable, then we have
* an interesting case. This is close to a Debian Firewall
* I tested in the past....
*
* The big difference between DhtStun and ProxyStun is
* that Dht Port receives unsolicated packets,
* while Proxy Port always sends an outgoing one first.
*
* In the case of the debian firewall, the unsolicated pkts
* caused the outgoing port to change.
*
* We will label this difference RESTRICTED vs FULL CONE,
* but that label is really fully accurate. (gray area).
*/
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_RESTRICTED_CONE;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_WARNING_NATTED;
}
}
else // Dht Stable.
{
/* DHT Stable port can be caused by:
* 1) Forwarded Port (UPNP, NATPMP, FORWARDED)
* 2) FULL CONE NAT.
* 3) EXT Port.
* Must look at Proxy Stability.
* - if Proxy Unstable, then must be forwarded port.
* - if Proxy Stable, then we cannot tell.
* -> Must use User Info (Upnp, PMP, Forwarded Flag).
* -> Also possible to be EXT Port (Check against iface)
*/
//mExtAddress = mStunDhtExtAddress;
//mExtAddrStable = true;
// Initial Fallback Guess at firewall state.
if (!mStunProxyStable)
{
/* must be a forwarded port/ext or something similar */
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_SYMMETRIC;
mNatHoleMode = PNSB_NATHOLE_FORWARDED;
mNetStateMode = PNSB_NETSTATE_GOOD;
}
else
{
/* fallback is FULL CONE NAT */
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_FULL_CONE;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_WARNING_NATTED;
}
if (mUPnPActive)
{
// This Mode is OKAY.
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
// Use Fallback Guess.
//mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_UPNP;
mNetStateMode = PNSB_NETSTATE_GOOD;
//mExtAddress = ... from UPnP, should match StunDht.
//mExtAddrStable = true;
}
else if (mNatPMPActive)
{
// This Mode is OKAY.
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
// Use Fallback Guess.
//mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_NATPMP;
mNetStateMode = PNSB_NETSTATE_GOOD;
//mExtAddress = ... from NatPMP, should match NatPMP
//mExtAddrStable = true;
}
else
{
bool isExtAddress = false;
if (isExtAddress)
{
mNetworkMode = PNSB_NETWORK_EXTERNALIP;
mNatTypeMode = PNSB_NATTYPE_NONE;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_GOOD;
//mExtAddrStable = true;
}
else if (mPortForwardedSet)
{
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
// Use Fallback Guess.
//mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_FORWARDED;
mNetStateMode = PNSB_NETSTATE_ADV_FORWARD;
//mExtAddrStable = true; // Probably, makin assumption.
}
else
{
/* At this point, we go with the fallback guesses */
}
}
}
}
}
else // DHT Inactive, must use other means...
{
/* If we get here we are dealing with a silly peer in "DarkMode".
* We have to primarily rely on the feedback from UPnP, PMP or WebSite "WhatsMyIp".
* This is in the "Advanced" Settings and liable to be set wrong.
* but thats the users fault!
*/
if (mUPnPActive)
{
// This Mode is OKAY.
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_UPNP;
//mExtAddress = ... from UPnP.
//mExtAddrStable = true;
mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
}
else if (mNatPMPActive)
{
// This Mode is OKAY.
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_NATPMP;
//mExtAddress = ... from NatPMP.
//mExtAddrStable = true;
mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
}
else
{
/* if we reach this point, we really need a Web "WhatsMyIp" Check of our Ext Ip Address. */
/* Check for the possibility of an EXT address ... */
bool isExtAddress = false;
//mExtAddress = ... from WhatsMyIp.
if (isExtAddress)
{
mNetworkMode = PNSB_NETWORK_EXTERNALIP;
mNatTypeMode = PNSB_NATTYPE_NONE;
mNatHoleMode = PNSB_NATHOLE_NONE;
//mExtAddrStable = true;
mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
}
else if (mPortForwardedSet)
{
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_FORWARDED;
//mExtAddrStable = true; // Probably, makin assumption.
mNetStateMode = PNSB_NETSTATE_WARNING_NODHT;
}
else
{
/* At this point we must assume firewalled.
* These people have destroyed the possibility of making connections ;(
* Should WARN about this.
*/
mNetworkMode = PNSB_NETWORK_BEHINDNAT;
mNatTypeMode = PNSB_NATTYPE_UNKNOWN;
mNatHoleMode = PNSB_NATHOLE_NONE;
mNetStateMode = PNSB_NETSTATE_BAD_NODHT_NAT;
//mExtAddrStable = false; // Unlikely to be stable.
}
}
}
workoutNetworkMode();
/* say that things are okay */
mStatusOkay = true;
mStatusTS = now;
}
/* based on calculated settings, what is the network mode
*/
void pqiNetStateBox::workoutNetworkMode()
{
/* connectModes are dependent on the other modes */
mConnectModes = PNSB_CONNECT_NONE;
switch(mNetworkMode)
{
case PNSB_NETWORK_UNKNOWN:
case PNSB_NETWORK_OFFLINE:
case PNSB_NETWORK_LOCALNET:
/* nothing here */
break;
case PNSB_NETWORK_EXTERNALIP:
mConnectModes = PNSB_CONNECT_OUTGOING_TCP;
mConnectModes |= PNSB_CONNECT_ACCEPT_TCP;
if (mDhtActive)
{
mConnectModes |= PNSB_CONNECT_DIRECT_UDP;
/* if open port. don't want PROXY or RELAY connect
* because we should be able to do direct with EVERYONE.
* Ability to do Proxy is dependent on FIREWALL status.
* Technically could do RELAY, but disable both.
*/
//mConnectModes |= PNSB_CONNECT_PROXY_UDP;
//mConnectModes |= PNSB_CONNECT_RELAY_UDP;
}
break;
case PNSB_NETWORK_BEHINDNAT:
mConnectModes = PNSB_CONNECT_OUTGOING_TCP;
/* we're okay if there's a NAT HOLE */
if ((mNatHoleMode == PNSB_NATHOLE_UPNP) ||
(mNatHoleMode == PNSB_NATHOLE_NATPMP) ||
(mNatHoleMode == PNSB_NATHOLE_FORWARDED))
{
mConnectModes |= PNSB_CONNECT_ACCEPT_TCP;
if (mDhtActive)
{
mConnectModes |= PNSB_CONNECT_DIRECT_UDP;
/* dont want PROXY | RELAY with open ports */
}
}
else
{
/* If behind NAT without NATHOLE, this is where RELAY | PROXY
* are useful. We Flag DIRECT connections, cos we can do these
* with peers with Open Ports. (but not with other NATted peers).
*/
if (mDhtActive)
{
mConnectModes |= PNSB_CONNECT_DIRECT_UDP;
mConnectModes |= PNSB_CONNECT_RELAY_UDP;
if ((mNatTypeMode == PNSB_NATTYPE_RESTRICTED_CONE) ||
(mNatTypeMode == PNSB_NATTYPE_FULL_CONE))
{
mConnectModes |= PNSB_CONNECT_PROXY_UDP;
}
}
}
break;
}
}

144
libretroshare/src/pqi/pqinetstatebox.h Normal file
View File

@ -0,0 +1,144 @@
#ifndef PQI_NET_STATUS_BOX_H
#define PQI_NET_STATUS_BOX_H
/* a little state box to determine network status */
#include <string>
#include <list>
#include "bitdht/bdiface.h"
/*** Network state
* Want this to be all encompassing.
*
*/
#define PNSB_NETWORK_UNKNOWN 1
#define PNSB_NETWORK_RESTARTING 2
#define PNSB_NETWORK_OFFLINE 3
#define PNSB_NETWORK_LOCALNET 4
#define PNSB_NETWORK_BEHINDNAT 5
#define PNSB_NETWORK_EXTERNALIP 6
// WHAT TYPE OF FIREWALL?
#define PNSB_NATTYPE_NONE 1
#define PNSB_NATTYPE_UNKNOWN 2
#define PNSB_NATTYPE_SYMMETRIC 3
#define PNSB_NATTYPE_RESTRICTED_CONE 4
#define PNSB_NATTYPE_FULL_CONE 5
#define PNSB_NATTYPE_OTHER 6
// WHAT TYPE OF HOLE?
#define PNSB_NATHOLE_UNKNOWN 0
#define PNSB_NATHOLE_NONE 1
#define PNSB_NATHOLE_UPNP 2
#define PNSB_NATHOLE_NATPMP 3
#define PNSB_NATHOLE_FORWARDED 4
// Types of Connections.
#define PNSB_CONNECT_NONE 0x0000
#define PNSB_CONNECT_ACCEPT_TCP 0x0001
#define PNSB_CONNECT_OUTGOING_TCP 0x0002
#define PNSB_CONNECT_DIRECT_UDP 0x0100
#define PNSB_CONNECT_PROXY_UDP 0x0200
#define PNSB_CONNECT_RELAY_UDP 0x0400
// net state (good, okay, bad)
// BAD. (RED)
#define PNSB_NETSTATE_BAD_UNKNOWN 1
#define PNSB_NETSTATE_BAD_OFFLINE 2
#define PNSB_NETSTATE_BAD_NATSYM 3
#define PNSB_NETSTATE_BAD_NODHT_NAT 4
// CAUTION. (ORANGE)
#define PNSB_NETSTATE_WARNING_RESTART 5
#define PNSB_NETSTATE_WARNING_NATTED 6
#define PNSB_NETSTATE_WARNING_NODHT 7
// GOOD (GREEN)
// NAT with forwarded port, or EXT port.
#define PNSB_NETSTATE_GOOD 8
// ADVANCED MODE (BLUE)
// If the user knows what they are doing... we cannot confirm this.
#define PNSB_NETSTATE_ADV_FORWARD 9
#define PNSB_NETSTATE_ADV_DARK_FORWARD 10
class pqiNetStateBox
{
public:
pqiNetStateBox();
/* input network bits */
void setAddressStunDht(struct sockaddr_in *, bool stable);
void setAddressStunProxy(struct sockaddr_in *, bool stable);
void setAddressUPnP(bool active, struct sockaddr_in *addr);
void setAddressNatPMP(bool active, struct sockaddr_in *addr);
void setAddressWebIP(bool active, struct sockaddr_in *addr);
void setDhtState(bool dhtOn, bool dhtActive);
uint32_t getNetStateMode();
uint32_t getNetworkMode();
uint32_t getNatTypeMode();
uint32_t getNatHoleMode();
uint32_t getConnectModes();
private:
/* calculate network state */
void clearOldNetworkData();
void determineNetworkState();
int statusOkay();
int updateNetState();
/* more internal fns */
void workoutNetworkMode();
bool mStatusOkay;
time_t mStatusTS;
uint32_t mNetworkMode;
uint32_t mNatTypeMode;
uint32_t mNatHoleMode;
uint32_t mConnectModes;
uint32_t mNetStateMode;
/* Parameters set externally */
bool mStunDhtSet;
time_t mStunDhtTS;
bool mStunDhtStable;
struct sockaddr_in mStunDhtAddr;
bool mStunProxySet;
time_t mStunProxyTS;
bool mStunProxyStable;
struct sockaddr_in mStunProxyAddr;
bool mDhtSet;
time_t mDhtTS;
bool mDhtOn;
bool mDhtActive;
bool mUPnPSet;
struct sockaddr_in mUPnPAddr;
bool mUPnPActive;
time_t mUPnPTS;
bool mNatPMPSet;
struct sockaddr_in mNatPMPAddr;
bool mNatPMPActive;
time_t mNatPMPTS;
bool mWebIPSet;
struct sockaddr_in mWebIPAddr;
bool mWebIPActive;
time_t mWebIPTS;
bool mPortForwardedSet;
uint16_t mPortForwarded;
};
#endif

4
libretroshare/src/retroshare/rsplugin.h
View File

@ -34,7 +34,7 @@ class RsPluginHandler ;
extern RsPluginHandler *rsPlugins ;
class p3Service ;
class p3ConnectMgr ;
class p3LinkMgr ;
class MainPage ;
class QIcon ;
class QString ;
@ -86,7 +86,7 @@ class RsPluginHandler
virtual const std::string& getLocalCacheDir() const =0;
virtual const std::string& getRemoteCacheDir() const =0;
virtual ftServer *getFileServer() const = 0;
virtual p3ConnectMgr *getConnectMgr() const = 0;
virtual p3LinkMgr *getLinkMgr() const = 0;
};

92
libretroshare/src/rsserver/rsinit.cc
View File

@ -1698,7 +1698,8 @@ RsTurtle *rsTurtle = NULL ;
#include "util/rsdebug.h"
#include "util/rsdir.h"
#include "util/rsrandom.h"
#include "upnp/upnphandler.h"
//#include "dht/opendhtmgr.h"
@ -1746,6 +1747,8 @@ RsTurtle *rsTurtle = NULL ;
#ifdef RS_USE_BITDHT
#include "dht/p3bitdht.h"
#include "dht/stunaddrassist.h"
#include "udp/udpstack.h"
#include "tcponudp/udppeer.h"
#include "tcponudp/udprelay.h"
@ -1850,7 +1853,7 @@ int RsServer::StartupRetroShare()
struct sockaddr_in tmpladdr;
sockaddr_clear(&tmpladdr);
tmpladdr.sin_port = htons(RsInitConfig::port);
rsUdpStack *mUdpStack = new rsUdpStack(tmpladdr);
rsUdpStack *mDhtStack = new rsUdpStack(tmpladdr);
#ifdef RS_USE_BITDHT
@ -1903,55 +1906,54 @@ int RsServer::StartupRetroShare()
int udpTypes[3];
// FIRST DHT STUNNER.
UdpStunner *mDhtStunner = new UdpStunner(mUdpStack);
mDhtStunner->setTargetStunPeriod(0); /* passive */
//mDhtStunner->setTargetStunPeriod(300); /* slow (5mins) */
mUdpStack->addReceiver(mDhtStunner);
UdpStunner *mDhtStunner = new UdpStunner(mDhtStack);
mDhtStunner->setTargetStunPeriod(300); /* slow (5mins) */
mDhtStack->addReceiver(mDhtStunner);
// NEXT BITDHT.
p3BitDht *mBitDht = new p3BitDht(ownId, mLinkMgr, mUdpStack, bootstrapfile);
p3BitDht *mBitDht = new p3BitDht(ownId, mLinkMgr, mNetMgr, mDhtStack, bootstrapfile);
/* install external Pointer for Interface */
rsDht = mBitDht;
// NEXT THE RELAY (NEED to keep a reference for installing RELAYS)
UdpRelayReceiver *mRelayRecver = new UdpRelayReceiver(mUdpStack);
udpReceivers[2] = mRelayRecver; /* RELAY Connections (DHT Port) */
UdpRelayReceiver *mRelay = new UdpRelayReceiver(mDhtStack);
udpReceivers[2] = mRelay; /* RELAY Connections (DHT Port) */
udpTypes[2] = TOU_RECEIVER_TYPE_UDPRELAY;
mUdpStack->addReceiver(udpReceivers[2]);
mDhtStack->addReceiver(udpReceivers[2]);
// LAST ON THIS STACK IS STANDARD DIRECT TOU
udpReceivers[0] = new UdpPeerReceiver(mUdpStack); /* standard DIRECT Connections (DHT Port) */
udpReceivers[0] = new UdpPeerReceiver(mDhtStack); /* standard DIRECT Connections (DHT Port) */
udpTypes[0] = TOU_RECEIVER_TYPE_UDPPEER;
mUdpStack->addReceiver(udpReceivers[0]);
mDhtStack->addReceiver(udpReceivers[0]);
// NOW WE BUILD THE SECOND STACK.
// Create the Second UdpStack... Port should be random (but openable!).
//struct sockaddr_in sndladdr;
//sockaddr_clear(&sndladdr);
//sndladdr.sin_port = htons(RsInitConfig::port + 1111);
//rsUdpStack *mUdpProxyStack = new rsUdpStack(sndladdr);
// XXX TODO
#define MIN_RANDOM_PORT 10000
#define MAX_RANDOM_PORT 30000
struct sockaddr_in sndladdr;
sockaddr_clear(&sndladdr);
uint16_t rndport = MIN_RANDOM_PORT + RSRandom::random_u32() % (MAX_RANDOM_PORT - MIN_RANDOM_PORT);
sndladdr.sin_port = htons(RsInitConfig::port);
rsFixedUdpStack *mProxyStack = new rsFixedUdpStack(sndladdr);
// FIRSTLY THE PROXY STUNNER.
//UdpStunner *mProxyStunner = new UdpStunner(mUdpProxyStack);
// USE DEFAULT PERIOD... mDhtStunner->setTargetStunPeriod(300); /* slow (5mins) */
//mUdpStack->addReceiver(mDhtStunner);
UdpStunner *mProxyStunner = new UdpStunner(mProxyStack);
mProxyStunner->setTargetStunPeriod(300); /* slow (5mins) */
mProxyStack->addReceiver(mProxyStunner);
// FINALLY THE PROXY UDP CONNECTIONS
//udpReceivers[1] = new UdpPeerReceiver(mUdpProxyStack); /* PROXY Connections (Alt UDP Port) */
//udpTypes[1] = TOU_RECEIVER_TYPE_UDPPEER;
//mUdpProxyStack->addReceiver(udpReceivers[1]);
udpReceivers[1] = new UdpPeerReceiver(mProxyStack); /* PROXY Connections (Alt UDP Port) */
udpTypes[1] = TOU_RECEIVER_TYPE_UDPPEER;
mProxyStack->addReceiver(udpReceivers[1]);
// REAL INITIALISATION - WITH THREE MODES
tou_init((void **) udpReceivers, udpTypes, 3);
mBitDht->setupConnectBits(mDhtStunner, mProxyStunner, mRelay);
// NOW WE CAN PASS THE RECEIVERS TO TOU.
// temp initialisation of only the DIRECT TOU.
tou_init((void **) udpReceivers, udpTypes, 1);
// REAL INITIALISATION - WITH THREE MODES - FOR LATER.
//tou_init((void **) udpReceivers, udpTypes, 3);
//mBitDht->setupConnectBits(mDhtStunner, mProxyStunner, mRelayRecver);
mBitDht->setupConnectBits(mDhtStunner, NULL, mRelayRecver);
mNetMgr->setAddrAssist(new stunAddrAssist(mDhtStunner), new stunAddrAssist(mProxyStunner));
#else
/* install NULL Pointer for rsDht Interface */
rsDht = NULL;
@ -1962,11 +1964,11 @@ int RsServer::StartupRetroShare()
SecurityPolicy *none = secpolicy_create();
pqih = new pqisslpersongrp(none, flags);
pqih = new pqisslpersongrp(none, flags, mPeerMgr);
//pqih = new pqipersongrpDummy(none, flags);
/****** New Ft Server **** !!! */
ftserver = new ftServer(mLinkMgr);
ftserver = new ftServer(mPeerMgr, mLinkMgr);
ftserver->setP3Interface(pqih);
ftserver->setConfigDirectory(RsInitConfig::configDir);
@ -2017,14 +2019,14 @@ int RsServer::StartupRetroShare()
//
mPluginsManager->setCacheDirectories(localcachedir,remotecachedir) ;
mPluginsManager->setFileServer(ftserver) ;
mPluginsManager->setConnectMgr(mConnMgr) ;
mPluginsManager->setLinkMgr(mLinkMgr) ;
// Now load the plugins. This parses the available SO/DLL files for known symbols.
//
mPluginsManager->loadPlugins(plugins_directories) ;
/* create Services */
ad = new p3disc(mLinkMgr, pqih);
ad = new p3disc(mPeerMgr, mLinkMgr, pqih);
#ifndef MINIMAL_LIBRS
msgSrv = new p3MsgService(mLinkMgr);
chatSrv = new p3ChatService(mLinkMgr);
@ -2091,7 +2093,9 @@ int RsServer::StartupRetroShare()
#ifdef RS_USE_BITDHT
mNetMgr->addNetAssistConnect(1, mBitDht);
mNetMgr->addNetListener(mUdpStack);
mNetMgr->addNetListener(mDhtStack);
mNetMgr->addNetListener(mProxyStack);
#endif
mNetMgr->addNetAssistFirewall(1, mUpnpMgr);
@ -2119,7 +2123,7 @@ int RsServer::StartupRetroShare()
mConfigMgr->addConfiguration("gpg_prefs.cfg", (AuthGPGimpl *) AuthGPG::getAuthGPG());
mConfigMgr->loadConfiguration();
mConfigMgr->addConfiguration("peers.cfg", mConnMgr);
mConfigMgr->addConfiguration("peers.cfg", mPeerMgr);
mConfigMgr->addConfiguration("general.cfg", mGeneralConfig);
mConfigMgr->addConfiguration("cache.cfg", mCacheStrapper);
#ifndef MINIMAL_LIBRS
@ -2176,12 +2180,14 @@ int RsServer::StartupRetroShare()
// universal
laddr.sin_addr.s_addr = inet_addr(RsInitConfig::inet);
mConnMgr->setLocalAddress(ownId, laddr);
mPeerMgr->setLocalAddress(ownId, laddr);
}
if (RsInitConfig::forceExtPort)
{
mConnMgr->setOwnNetConfig(RS_NET_MODE_EXT, RS_VIS_STATE_STD);
mPeerMgr->setOwnNetworkMode(RS_NET_MODE_EXT);
mPeerMgr->setOwnVisState(RS_VIS_STATE_STD);
}
#if 0
@ -2197,14 +2203,14 @@ int RsServer::StartupRetroShare()
}
#endif
mConnMgr -> checkNetAddress();
mNetMgr -> checkNetAddress();
/**************************************************************************/
/* startup (stuff dependent on Ids/peers is after this point) */
/**************************************************************************/
pqih->init_listener();
mConnMgr->addNetListener(pqih); /* add listener so we can reset all sockets later */
mNetMgr->addNetListener(pqih); /* add listener so we can reset all sockets later */
@ -2291,7 +2297,7 @@ int RsServer::StartupRetroShare()
/* Setup GUI Interfaces. */
rsPeers = new p3Peers(mConnMgr);
rsPeers = new p3Peers(mLinkMgr, mPeerMgr, mNetMgr);
rsDisc = new p3Discovery(ad);
#ifndef MINIMAL_LIBRS

23
libretroshare/src/tcponudp/rsudpstack.h
View File

@ -69,4 +69,27 @@ virtual bool resetListener(struct sockaddr_in &local)
};
class rsFixedUdpStack: public UdpStack, public pqiNetListener
{
public:
rsFixedUdpStack(struct sockaddr_in &local)
:UdpStack(local) { return; }
/* from pqiNetListener */
virtual bool resetListener(struct sockaddr_in &local)
{
struct sockaddr_in addr;
getLocalAddress(addr);
// The const_cast below is not so nice but without it, the compiler can't
// find the correct operator<<(). No idea why!
std::cerr << "rsFixedUdpStack::resetListener(" << const_cast<const struct sockaddr_in &>(local) << ")";
std::cerr << " Resetting with original addr: " << const_cast<const struct sockaddr_in &>(addr);
std::cerr << std::endl;
return resetAddress(addr);
}
};
#endif