Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-12-27 16:39:29 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

--- Merging r4753 through r4779 from /svnroot/retroshare/branches/v0.5-dhtmods

Browse Source 
Merging Dht Relay improvements into the trunk. These changes should finally make relays functional.
There are still some service changes required to reduce the traffic over relays.

Summary of Changes
---------------------

 * Changed the way proxy/relay peers are selected in bdConnection. (needs more work).
 * Added LinkType to peer info in p3LinkMgr & rspeers.h interface.
 * Added getConnectionType() to p3PeerMgr. This defaults to FRIEND for the moment.
 * Provide information about Bandwidth, Transport and Peer Type via LinkType().
 * Added RateCap() to limit traffic over Relay connections.
 * Set Internal Rate to 75% of Relay Limit to account for transport overhead.
 * Added various #include "util/rswin.h" to fix compile errors with standard ssl package.
 * Removed Local variables (mConnectProxyAddr, etc) which were hiding Class Variables.
 * Cleaned up bits in pqissl.cc and p3linkmgr.cc
 * Increased UDP Relay Packet size (max transport of 1400 bytes per UDP packet)
 * Modified checkRelay() to use Low Pass Filter to calculate Relay Bandwidth.
 * Improved udprelay debugging.
 * increased (x2) Relay Lifetimes - this is so that enough useful data can be transported (1meg).
 * Added LOCALNET_TESTING code to rsinit.cc. This allows Port Restrictions to simulate firewalls.
 * more debugging and minor bugfixes.




git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@4780 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2012-01-11 11:54:28 +00:00
commit fc949ce5d0
34 changed files with 690 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
libbitdht/src/bitdht/bdconnection.cc
View File

@ -35,12 +35,15 @@
#include "util/bdrandom.h"
/*
* #define DEBUG_PROXY_CONNECTION 1
* #define DEBUG_NODE_CONNECTION 1
* #define DEBUG_NODE_CONNECTION_EXTRA 1
* #define DEBUG_CONNECTION_DELAY 1
*/
#define DEBUG_CONNECTION_DELAY 1
//#define DEBUG_PROXY_CONNECTION 1
//#define DEBUG_NODE_CONNECTION 1
//#define DEBUG_CONNECTION_DELAY 1
#define BITDHT_CR_PAUSE_SHORT_PERIOD 1
@ -341,7 +344,7 @@ int bdConnectManager::requestConnection_direct(struct sockaddr_in *laddr, bdNode
int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay)
{
#ifdef DEBUG_NODE_CONNECTION
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy()";
std::cerr << std::endl;
#endif
@ -349,7 +352,7 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
if (checkExistingConnectionAttempt(target))
{
#ifdef DEBUG_NODE_CONNECTION
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() Existing ConnectionRequest... NOOP";
std::cerr << std::endl;
#endif
@ -360,10 +363,28 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
bdConnectionRequest connreq;
connreq.setupProxyConnection(laddr, target, mode, delay);
/* grab any peers from any existing query */
/****
* We want different behaviour here - depending on whether it is a proxy or a relay request
* furthermore if we are in relay server mode - we should only use those.
*
* Try to unify logic.
*
* Proxy - take potential proxies...
* - if RelayServerMode then relays.
* - take friends, friends of friends.
*
* Relay -
* - if RelayServerMode take relays.
* - take friends, friends of friends
* - take potential proxies.
*/
/* get the proxy lists from existing query */
std::list<bdId>::iterator pit;
std::list<bdId> goodProxies;
std::list<bdId> potentialProxies;
mQueryMgr->proxies(target, connreq.mGoodProxies);
mQueryMgr->proxies(target, goodProxies);
mQueryMgr->potentialProxies(target, potentialProxies);
/* check any potential proxies, must be same DHT Type */
@ -372,7 +393,12 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
/* check the type in bdSpace */
if (checkPeerForFlag(&(*pit), BITDHT_PEER_STATUS_DHT_ENGINE_VERSION))
{
connreq.mGoodProxies.push_back(*pit);
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() Shifting Pot -> Good: ";
mFns->bdPrintId(std::cerr, &(*pit));
std::cerr << std::endl;
#endif
goodProxies.push_back(*pit);
pit = potentialProxies.erase(pit);
}
else
@ -381,6 +407,108 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
}
}
/* in proxy mode - put Good Proxies First */
if (mode == BITDHT_CONNECT_MODE_PROXY)
{
for(pit = goodProxies.begin(); pit != goodProxies.end(); pit++)
{
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() Adding Good Proxy: ";
mFns->bdPrintId(std::cerr, &(*pit));
std::cerr << std::endl;
#endif
connreq.mGoodProxies.push_back(*pit);
}
}
if (mRelayMode)
{
/* Add Relay Servers */
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() In RelayMode... adding Relays";
#endif
std::list<bdId> excluding;
std::multimap<bdMetric, bdId> nearest;
int number = CONNECT_NUM_PROXY_ATTEMPTS;
mNodeSpace->find_nearest_nodes_with_flags(target, number, excluding, nearest,
BITDHT_PEER_STATUS_DHT_RELAY_SERVER);
std::multimap<bdMetric, bdId>::iterator it;
for(it = nearest.begin(); it != nearest.end(); it++)
{
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() Adding Relay Server: ";
mFns->bdPrintId(std::cerr, &(it->second));
std::cerr << std::endl;
#endif
connreq.mGoodProxies.push_back(it->second);
}
}
{
std::list<bdId> excluding;
std::multimap<bdMetric, bdId> nearest;
int number = CONNECT_NUM_PROXY_ATTEMPTS;
mNodeSpace->find_nearest_nodes_with_flags(target, number, excluding, nearest,
BITDHT_PEER_STATUS_DHT_FRIEND);
std::multimap<bdMetric, bdId>::iterator it;
for(it = nearest.begin(); it != nearest.end(); it++)
{
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() Adding Friend: ";
mFns->bdPrintId(std::cerr, &(it->second));
std::cerr << std::endl;
#endif
connreq.mGoodProxies.push_back(it->second);
}
}
/* in relay mode - Good Proxies are the BackUp */
if (mode == BITDHT_CONNECT_MODE_RELAY)
{
for(pit = goodProxies.begin(); pit != goodProxies.end(); pit++)
{
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() Adding Good Proxy: ";
mFns->bdPrintId(std::cerr, &(*pit));
std::cerr << std::endl;
#endif
connreq.mGoodProxies.push_back(*pit);
}
}
// Final Desperate Measures!
if (connreq.mGoodProxies.size() < MED_START_PROXY_COUNT)
{
std::list<bdId> excluding;
std::multimap<bdMetric, bdId> nearest;
int number = CONNECT_NUM_PROXY_ATTEMPTS;
mNodeSpace->find_nearest_nodes_with_flags(target, number, excluding, nearest,
BITDHT_PEER_STATUS_DHT_FOF);
std::multimap<bdMetric, bdId>::iterator it;
for(it = nearest.begin(); it != nearest.end(); it++)
{
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() Querying FOF: ";
mFns->bdPrintId(std::cerr, &(it->second));
std::cerr << std::endl;
#endif
//connreq.mGoodProxies.push_back(it->second);
mPub->send_query(&(it->second), target);
}
}
/* if we don't have enough proxies ... ping the potentials */
if (connreq.mGoodProxies.size() < MED_START_PROXY_COUNT)
@ -396,7 +524,7 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
mPub->send_ping(&(*pit));
#ifdef DEBUG_NODE_CONNECTION
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() Pinging Potential Proxy";
mFns->bdPrintId(std::cerr, &(*pit));
std::cerr << std::endl;
@ -404,6 +532,12 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
}
}
/*** ORIGINAL CODE - TRIES TO PING/SEARCH PEERS - INSTEAD OF JUST TRYING THEM
* NOT SURE WHAT THE BEST PLAN IS.....
* LEAVE THIS CODE HERE FOR REFERENCE....
***/
#if 0
// Final Desperate Measures!
if (connreq.mGoodProxies.size() < MED_START_PROXY_COUNT)
{
@ -445,6 +579,7 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
mPub->send_query(&(it->second), target);
}
}
#endif
if (connreq.mGoodProxies.size() < 1)
@ -455,7 +590,7 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
if (connreq.mGoodProxies.size() < MIN_START_PROXY_COUNT)
{
#ifdef DEBUG_NODE_CONNECTION
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() WARNING initial proxyList.size() == SMALL PAUSING";
std::cerr << std::endl;
#endif
@ -466,7 +601,7 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
connreq.mPauseTS = now + BITDHT_CR_PAUSE_START_PERIOD;
}
#ifdef DEBUG_NODE_CONNECTION
#ifdef DEBUG_PROXY_CONNECTION
std::cerr << "bdConnectManager::requestConnection_proxy() CRINITSTATE Init Connection State";
std::cerr << std::endl;
std::cerr << connreq;
@ -480,6 +615,9 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
return 1;
}
void bdConnectManager::addPotentialConnectionProxy(const bdId *srcId, const bdId *target)
{
#ifdef DEBUG_NODE_CONNECTION_EXTRA

23
libbitdht/src/bitdht/bdmanager.cc
View File

@ -1434,3 +1434,26 @@ int bdDebugCallback::dhtConnectCallback(const bdId *srcId, const bdId *proxyId,
return 1;
}
int bdDebugCallback::dhtInfoCallback(const bdId *id, uint32_t type, uint32_t flags, std::string info)
{
/* remove unused parameter warnings */
(void) id;
(void) type;
(void) flags;
(void) info;
#ifdef DEBUG_MGR
std::cerr << "bdDebugCallback::dhtInfoCallback() Type: " << type;
std::cerr << " Id: ";
bdStdPrintId(std::cerr, id);
std::cerr << " flags: " << flags;
std::cerr << " info: " << info;
std::cerr << std::endl;
#endif
return 1;
}

1
libbitdht/src/bitdht/bdmanager.h
View File

@ -201,6 +201,7 @@ virtual int dhtPeerCallback(const bdId *id, uint32_t status);
virtual int dhtValueCallback(const bdNodeId *id, std::string key, uint32_t status);
virtual int dhtConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId *destId,
uint32_t mode, uint32_t point, uint32_t param, uint32_t cbtype, uint32_t errcode);
virtual int dhtInfoCallback(const bdId *id, uint32_t type, uint32_t flags, std::string info);
};

26
libbitdht/src/bitdht/bdnode.cc
View File

@ -60,9 +60,12 @@
* #define DEBUG_NODE_MSGIN 1
* #define DEBUG_NODE_MSGOUT 1
*
* #define DISABLE_BAD_PEER_FILTER 1
*
***/
//#define DEBUG_NODE_MSGS 1
//#define DISABLE_BAD_PEER_FILTER 1
bdNode::bdNode(bdNodeId *ownId, std::string dhtVersion, std::string bootfile, bdDhtFunctions *fns)
@ -461,9 +464,6 @@ void bdNode::send_connect_msg(bdId *id, int msgtype, bdId *srcAddr, bdId *destAd
}
//#define DISABLE_BAD_PEER_FILTER 1
void bdNode::checkPotentialPeer(bdId *id, bdId *src)
{
/* Check BadPeer Filters for Potential Peers too */
@ -488,6 +488,7 @@ void bdNode::checkPotentialPeer(bdId *id, bdId *src)
{
if (knownAddr.sin_addr.s_addr != id->addr.sin_addr.s_addr)
{
#ifndef DISABLE_BAD_PEER_FILTER
std::cerr << "bdNode::checkPotentialPeer(";
mFns->bdPrintId(std::cerr, id);
std::cerr << ") MASQARADING AS KNOWN PEER - FLAGGING AS BAD";
@ -496,7 +497,6 @@ void bdNode::checkPotentialPeer(bdId *id, bdId *src)
// Stores in queue for later callback and desemination around the network.
mBadPeerQueue.queuePeer(id, 0);
#ifndef DISABLE_BAD_PEER_FILTER
mFilterPeers->addPeerToFilter(id, 0);
std::list<struct sockaddr_in> filteredIPs;
@ -574,6 +574,7 @@ void bdNode::addPeer(const bdId *id, uint32_t peerflags)
{
if (knownAddr.sin_addr.s_addr != id->addr.sin_addr.s_addr)
{
#ifndef DISABLE_BAD_PEER_FILTER
std::cerr << "bdNode::addPeer(";
mFns->bdPrintId(std::cerr, id);
std::cerr << ", " << std::hex << peerflags << std::dec;
@ -584,13 +585,11 @@ void bdNode::addPeer(const bdId *id, uint32_t peerflags)
// Stores in queue for later callback and desemination around the network.
mBadPeerQueue.queuePeer(id, peerflags);
#ifndef DISABLE_BAD_PEER_FILTER
mFilterPeers->addPeerToFilter(id, peerflags);
std::list<struct sockaddr_in> filteredIPs;
mFilterPeers->filteredIPs(filteredIPs);
mStore.filterIpList(filteredIPs);
#endif
// DO WE EXPLICITLY NEED TO DO THIS, OR WILL THEY JUST BE DROPPED?
//mNodeSpace.remove_badpeer(id);
@ -599,7 +598,6 @@ void bdNode::addPeer(const bdId *id, uint32_t peerflags)
// FLAG in NodeSpace (Should be dropped very quickly anyway)
mNodeSpace.flagpeer(id, 0, BITDHT_PEER_EXFLAG_BADPEER);
#ifndef DISABLE_BAD_PEER_FILTER
return;
#endif
}
@ -657,15 +655,23 @@ void bdNode::processRemoteQuery()
case BD_QUERY_NEIGHBOURS:
{
/* search bdSpace for neighbours */
//std::list<bdId> excludeList;
std::list<bdId> nearList;
std::multimap<bdMetric, bdId> nearest;
std::multimap<bdMetric, bdId>::iterator it;
//mNodeSpace.find_nearest_nodes(&(query.mQuery), BITDHT_QUERY_NEIGHBOUR_PEERS, excludeList, nearest, 0);
if (mRelayMode == BITDHT_RELAYS_SERVER)
{
std::list<bdId> excludeList;
mNodeSpace.find_nearest_nodes_with_flags(&(query.mQuery),
BITDHT_QUERY_NEIGHBOUR_PEERS,
excludeList, nearest, BITDHT_PEER_STATUS_DHT_RELAY_SERVER);
}
else
{
mNodeSpace.find_nearest_nodes(&(query.mQuery), BITDHT_QUERY_NEIGHBOUR_PEERS, nearest);
}
for(it = nearest.begin(); it != nearest.end(); it++)
{

2
libbitdht/src/example/Makefile
View File

@ -1,6 +1,6 @@
CXXFLAGS = -Wall -g -I..
#CXXFLAGS += -arch i386 # OSX
CXXFLAGS += -arch i386 # OSX
LIBS = -L../lib -lbitdht

16
libbitdht/src/example/bdhandler.cc
View File

@ -45,7 +45,7 @@ virtual int dhtNodeCallback(const bdId *id, uint32_t peerflags)
return mParent->NodeCallback(id, peerflags);
}
virtual int dhtPeerCallback(const bdNodeId *id, uint32_t status)
virtual int dhtPeerCallback(const bdId *id, uint32_t status)
{
return mParent->PeerCallback(id, status);
}
@ -55,6 +55,16 @@ virtual int dhtValueCallback(const bdNodeId *id, std::string key, uint32_t statu
return mParent->ValueCallback(id, key, status);
}
virtual int dhtConnectCallback(const bdId*, const bdId*, const bdId*, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)
{
return 1;
}
virtual int dhtInfoCallback(const bdId*, uint32_t, uint32_t, std::string)
{
return 1;
}
private:
BitDhtHandler *mParent;
@ -187,10 +197,10 @@ int BitDhtHandler::NodeCallback(const bdId *id, uint32_t peerflags)
return 0;
}
int BitDhtHandler::PeerCallback(const bdNodeId *id, uint32_t status)
int BitDhtHandler::PeerCallback(const bdId *id, uint32_t status)
{
std::cerr << "BitDhtHandler::PeerCallback() NodeId: ";
bdStdPrintNodeId(std::cerr, id);
bdStdPrintId(std::cerr, id);
std::cerr << std::endl;
bool connect = false;

2
libbitdht/src/example/bdhandler.h
View File

@ -55,7 +55,7 @@ bool FindNode(bdNodeId *peerId);
bool DropNode(bdNodeId *peerId);
virtual int NodeCallback(const bdId *id, uint32_t peerflags);
virtual int PeerCallback(const bdNodeId *id, uint32_t status);
virtual int PeerCallback(const bdId *id, uint32_t status);
virtual int ValueCallback(const bdNodeId *id, std::string key, uint32_t status);
private:

4
libbitdht/src/tests/scripts/config.mk
View File

@ -4,8 +4,8 @@
###########################################################################
#Define OS.
#
OS = Linux
#OS = MacOSX
#OS = Linux
OS = MacOSX
#OS = Cygwin
#OS = Win # MinGw.
###########################################################################

4
libbitdht/src/udp/udpbitdht.cc
View File

@ -51,8 +51,8 @@
// Original RS 0.5.0/0.5.1 version, is un-numbered.
//#define BITDHT_VERSION "00" // First Release of BitDHT with Connections (Proxy Support + Dht Stun)
#define BITDHT_VERSION "01" // Testing Connections
//#define BITDHT_VERSION "02" // Completed? Full Connections
//#define BITDHT_VERSION "01" // Testing Connections (Proxy Only)
#define BITDHT_VERSION "02" // Completed Relay Connections from svn 4766
//#define BITDHT_VERSION "04" // Full DHT implementation.?
/*************************************/

9
libretroshare/src/dht/connectstatebox.cc
View File

@ -38,6 +38,7 @@
*
**/
/* Have made the PROXY Attempts + MAX_TIME much larger,
* have have potential for this to take a while.
*/
@ -46,18 +47,18 @@
#define FAILED_WAIT_TIME (1800) // 5 minutes.
#define TCP_WAIT_TIME (10) // 1/6 minutes.
#define DIRECT_MAX_WAIT_TIME (30) // 1/6 minutes.
#define PROXY_BASE_WAIT_TIME (30) // 1/6 minutes.
#define PROXY_MAX_WAIT_TIME (120) // 1/6 minutes.
#define PROXY_BASE_WAIT_TIME (10) // 30 // 1/6 minutes.
#define PROXY_MAX_WAIT_TIME (30) // 120 // 1/6 minutes.
#define RELAY_MAX_WAIT_TIME (30) // 1/6 minutes.
#define REVERSE_WAIT_TIME (30) // 1/2 minutes.
#define MAX_DIRECT_ATTEMPTS (3)
#define MAX_PROXY_ATTEMPTS (10)
#define MAX_PROXY_ATTEMPTS (3)
#define MAX_RELAY_ATTEMPTS (3)
#define MAX_DIRECT_FAILED_ATTEMPTS (1)
#define MAX_PROXY_FAILED_ATTEMPTS (2)
#define MAX_RELAY_FAILED_ATTEMPTS (1)
#define MAX_RELAY_FAILED_ATTEMPTS (2)
#else
#define FAILED_WAIT_TIME (1800) // 30 minutes.
#define TCP_WAIT_TIME (60) // 1 minutes.

2
libretroshare/src/dht/p3bitdht.cc
View File

@ -96,6 +96,8 @@ p3BitDht::p3BitDht(std::string id, pqiConnectCb *cb, p3NetMgr *nm,
std::string dhtVersion = "RS51"; // should come from elsewhere!
mOwnRsId = id;
mMinuteTS = 0;
#ifdef DEBUG_BITDHT
std::cerr << "p3BitDht::p3BitDht()" << std::endl;
std::cerr << "Using Id: " << id;

5
libretroshare/src/dht/p3bitdht_peernet.cc
View File

@ -32,7 +32,6 @@
**/
/******************************************************************************************
************************************* Dht Callback ***************************************
******************************************************************************************/
@ -1087,6 +1086,7 @@ int p3BitDht::tick()
}
#define MINUTE_IN_SECS 60
#define TEN_IN_SECS 10
int p3BitDht::minuteTick()
{
@ -1098,7 +1098,8 @@ int p3BitDht::minuteTick()
deltaT = now-mMinuteTS;
}
if (deltaT > MINUTE_IN_SECS)
//if (deltaT > MINUTE_IN_SECS)
if (deltaT > TEN_IN_SECS)
{
mRelay->checkRelays();

1
libretroshare/src/pqi/authgpg.h
View File

@ -39,6 +39,7 @@
#ifndef RS_GPG_AUTH_HEADER
#define RS_GPG_AUTH_HEADER
#include "util/rswin.h"
#include <gpgme.h>
#include <openssl/ssl.h>
#include <openssl/evp.h>

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

@ -39,6 +39,8 @@
*
*/
#include "util/rswin.h"
#include <openssl/ssl.h>
#include <openssl/evp.h>

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

@ -43,7 +43,9 @@ const int p3connectzone = 3431;
#include "serialiser/rsconfigitems.h"
#include "pqi/pqinotify.h"
#include "retroshare/rsiface.h"
#include "retroshare/rspeers.h"
#include <sstream>
@ -208,6 +210,28 @@ bool p3LinkMgrIMPL::isOnline(const std::string &ssl_id)
return false;
}
uint32_t p3LinkMgrIMPL::getLinkType(const std::string &ssl_id)
{
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it;
it = mFriendList.find(ssl_id);
if (it == mFriendList.end())
{
return 0;
}
if (it->second.state & RS_PEER_S_CONNECTED)
{
return it->second.linkType;
}
return 0;
}
void p3LinkMgrIMPL::getOnlineList(std::list<std::string> &ssl_peers)
{
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
@ -654,11 +678,82 @@ bool p3LinkMgrIMPL::connectAttempt(const std::string &id, struct sockaddr_in &ra
srcaddr = it->second.currentConnAddrAttempt.srcaddr;
bandwidth = it->second.currentConnAddrAttempt.bandwidth;
/********* Setup LinkType parameters **********/
#define TRICKLE_LIMIT 2001 // 2kb
#define LOW_BANDWIDTH_LIMIT 5001 // 5kb
it->second.linkType = 0;
if (type & RS_NET_CONN_TCP_ALL)
{
it->second.linkType |= RS_NET_CONN_TRANS_TCP_UNKNOWN;
}
else if (type & RS_NET_CONN_UDP_ALL)
{
if (flags & RS_CB_FLAG_MODE_UDP_DIRECT)
{
it->second.linkType |= RS_NET_CONN_TRANS_UDP_DIRECT;
}
else if (flags & RS_CB_FLAG_MODE_UDP_PROXY)
{
it->second.linkType |= RS_NET_CONN_TRANS_UDP_PROXY;
}
else if (flags & RS_CB_FLAG_MODE_UDP_RELAY)
{
it->second.linkType |= RS_NET_CONN_TRANS_UDP_RELAY;
}
else
{
it->second.linkType |= RS_NET_CONN_TRANS_UDP_UNKNOWN;
}
}
else if (type & RS_NET_CONN_TUNNEL)
{
it->second.linkType |= RS_NET_CONN_TRANS_TUNNEL;
}
else
{
it->second.linkType |= RS_NET_CONN_TRANS_UNKNOWN;
}
if (flags & RS_CB_FLAG_MODE_UDP_RELAY)
{
if (bandwidth < TRICKLE_LIMIT)
{
it->second.linkType |= RS_NET_CONN_SPEED_TRICKLE;
}
else if (bandwidth < LOW_BANDWIDTH_LIMIT)
{
it->second.linkType |= RS_NET_CONN_SPEED_LOW;
}
else
{
it->second.linkType |= RS_NET_CONN_SPEED_NORMAL;
}
}
else
{
it->second.linkType |= RS_NET_CONN_SPEED_NORMAL;
}
uint32_t connType = mPeerMgr->getConnectionType(id);
it->second.linkType |= connType;
/********* Setup LinkType parameters **********/
// TEMP DEBUG.
std::cerr << "p3LinkMgrIMPL::connectAttempt() found an address: id: " << id << std::endl;
std::cerr << " laddr: " << rs_inet_ntoa(raddr.sin_addr) << " lport: " << ntohs(raddr.sin_port) << " delay: " << delay << " period: " << period;
std::cerr << " type: " << type << std::endl;
std::cerr << "p3LinkMgrIMPL::connectAttempt() set LinkType to: " << it->second.linkType << std::endl;
#ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::connectAttempt() found an address: id: " << id << std::endl;
std::cerr << " laddr: " << rs_inet_ntoa(addr.sin_addr) << " lport: " << ntohs(addr.sin_port) << " delay: " << delay << " period: " << period;
std::cerr << " type: " << type << std::endl;
std::cerr << "p3LinkMgrIMPL::connectAttempt() set LinkType to: " << it->second.linkType << std::endl;
#endif
if (raddr.sin_addr.s_addr == 0 || raddr.sin_port == 0) {
#ifdef LINKMGR_DEBUG
@ -1485,9 +1580,7 @@ bool p3LinkMgrIMPL::retryConnectTCP(const std::string &id)
std::map<std::string, peerConnectState>::iterator it;
if (mFriendList.end() != (it = mFriendList.find(id)))
{
locked_ConnectAttempt_CurrentAddresses(&(it->second), &lAddr, &eAddr);
locked_ConnectAttempt_HistoricalAddresses(&(it->second), histAddrs);
uint16_t dynPort = ntohs(eAddr.sin_port);
if (!dynPort)
@ -1497,6 +1590,8 @@ bool p3LinkMgrIMPL::retryConnectTCP(const std::string &id)
locked_ConnectAttempt_AddDynDNS(&(it->second), dyndns, dynPort);
}
locked_ConnectAttempt_HistoricalAddresses(&(it->second), histAddrs);
//locked_ConnectAttempt_AddTunnel(&(it->second));
/* finish it off */

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

@ -29,8 +29,6 @@
#include "pqi/pqimonitor.h"
#include "pqi/pqiipset.h"
//#include "pqi/p3dhtmgr.h"
//#include "pqi/p3upnpmgr.h"
#include "pqi/pqiassist.h"
#include "pqi/p3cfgmgr.h"
@ -40,22 +38,17 @@
class ExtAddrFinder ;
class DNSResolver ;
/* 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 */
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 */
const uint32_t RS_TCP_STD_TIMEOUT_PERIOD = 5; /* 5 seconds! */
const uint32_t RS_UDP_STD_TIMEOUT_PERIOD = 80; /* 80 secs, allows UDP TTL to get to 40! - Plenty of time (30+80) = 110 secs */
@ -95,38 +88,20 @@ class peerConnectState
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;
/* list of addresses from various sources */
//pqiIpAddrSet ipAddrs;
/***** Below here not stored permanently *****/
bool dhtVisible;
//time_t lastcontact;
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 linkType;
uint32_t source; /* most current source */
peerAddrInfo dht;
@ -170,6 +145,7 @@ virtual const std::string getOwnId() = 0;
virtual bool isOnline(const std::string &ssl_id) = 0;
virtual void getOnlineList(std::list<std::string> &ssl_peers) = 0;
virtual bool getPeerName(const std::string &ssl_id, std::string &name) = 0;
virtual uint32_t getLinkType(const std::string &ssl_id) = 0;
/**************** handle monitors *****************/
virtual void addMonitor(pqiMonitor *mon) = 0;
@ -226,6 +202,7 @@ virtual const std::string getOwnId();
virtual bool isOnline(const std::string &ssl_id);
virtual void getOnlineList(std::list<std::string> &ssl_peers);
virtual bool getPeerName(const std::string &ssl_id, std::string &name);
virtual uint32_t getLinkType(const std::string &ssl_id);
/**************** handle monitors *****************/

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

@ -271,6 +271,11 @@ bool p3PeerMgrIMPL::getGpgId(const std::string &ssl_id, std::string &gpgId)
return true;
}
// Placeholder until we implement this functionality.
uint32_t p3PeerMgrIMPL::getConnectionType(const std::string &sslId)
{
return RS_NET_CONN_TYPE_FRIEND;
}
bool p3PeerMgrIMPL::getFriendNetStatus(const std::string &id, peerState &state)

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

@ -183,6 +183,7 @@ virtual bool getOthersNetStatus(const std::string &id, peerState &state) = 0;
virtual bool getPeerName(const std::string &ssl_id, std::string &name) = 0;
virtual bool getGpgId(const std::string &sslId, std::string &gpgId) = 0;
virtual uint32_t getConnectionType(const std::string &sslId) = 0;
/************* DEPRECIATED FUNCTIONS (TO REMOVE) ********/
@ -268,6 +269,7 @@ virtual bool getOthersNetStatus(const std::string &id, peerState &state);
virtual bool getPeerName(const std::string &ssl_id, std::string &name);
virtual bool getGpgId(const std::string &sslId, std::string &gpgId);
virtual uint32_t getConnectionType(const std::string &sslId);
/************* DEPRECIATED FUNCTIONS (TO REMOVE) ********/

45
libretroshare/src/pqi/pqi_base.h
View File

@ -58,7 +58,9 @@ class RateInterface
public:
RateInterface()
:bw_in(0), bw_out(0), bwMax_in(0), bwMax_out(0) { return; }
:bw_in(0), bw_out(0), bwMax_in(0), bwMax_out(0),
bwCapEnabled(false), bwCap_in(0), bwCap_out(0) { return; }
virtual ~RateInterface() { return; }
virtual float getRate(bool in)
@ -78,12 +80,50 @@ virtual float getMaxRate(bool in)
virtual void setMaxRate(bool in, float val)
{
if (in)
{
bwMax_in = val;
if (bwCapEnabled)
{
if (bwMax_in > bwCap_in)
{
bwMax_in = bwCap_in;
}
}
}
else
{
bwMax_out = val;
if (bwCapEnabled)
{
if (bwMax_out > bwCap_out)
{
bwMax_out = bwCap_out;
}
}
}
return;
}
virtual void setRateCap(float val_in, float val_out)
{
if ((val_in == 0) && (val_out == 0))
{
std::cerr << "RateInterface::setRateCap() Now disabled" << std::endl;
bwCapEnabled = false;
}
else
{
std::cerr << "RateInterface::setRateCap() Enabled ";
std::cerr << "in: " << bwCap_in << " out: " << bwCap_out << std::endl;
bwCapEnabled = true;
bwCap_in = val_in;
bwCap_out = val_out;
}
return;
}
protected:
void setRate(bool in, float val)
@ -97,6 +137,9 @@ void setRate(bool in, float val)
private:
float bw_in, bw_out, bwMax_in, bwMax_out;
bool bwCapEnabled;
float bwCap_in, bwCap_out;
};

19
libretroshare/src/pqi/pqiperson.cc
View File

@ -189,7 +189,7 @@ int pqiperson::notifyEvent(NetInterface *ni, int newState)
out << i << " of " << kids.size();
out << std::endl;
out << " type: " << (it->first);
out << " ni: " << (it->second)->ni;
//out << " ni: " << (it->second)->ni;
out << " in_ni: " << ni;
pqioutput(PQL_DEBUG_BASIC, pqipersonzone, out.str());
i++;
@ -431,6 +431,9 @@ int pqiperson::connect(uint32_t type, struct sockaddr_in raddr,
pqioutput(PQL_WARNING, pqipersonzone, "pqiperson::connect reset() before connection attempt");
(it->second)->reset();
std::cerr << "pqiperson::connect() WARNING, clearing rate cap" << std::endl;
setRateCap(0,0);
#ifdef PERSON_DEBUG
std::cerr << "pqiperson::connect() setting connect_parameters" << std::endl;
#endif
@ -489,3 +492,17 @@ void pqiperson::setMaxRate(bool in, float val)
}
}
void pqiperson::setRateCap(float val_in, float val_out)
{
// set to all of them. (and us)
PQInterface::setRateCap(val_in, val_out);
// clean up the children.
std::map<uint32_t, pqiconnect *>::iterator it;
for(it = kids.begin(); it != kids.end(); it++)
{
(it->second) -> setRateCap(val_in, val_out);
}
}

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

@ -92,7 +92,7 @@ virtual std::string PeerId()
// to check if our interface.
virtual bool thisNetInterface(NetInterface *ni_in) { return (ni_in == ni); }
//protected:
protected:
NetBinInterface *ni;
protected:
};
@ -138,6 +138,7 @@ int notifyEvent(NetInterface *ni, int event);
// PQInterface for rate control overloaded....
virtual float getRate(bool in);
virtual void setMaxRate(bool in, float val);
virtual void setRateCap(float val_in, float val_out);
pqiconnect *getKid(uint32_t type);

6
libretroshare/src/pqi/pqissl.cc
View File

@ -101,7 +101,6 @@ pqissl::pqissl(pqissllistener *l, PQInterface *parent, p3LinkMgr *lm)
pqil(l), // no init for remote_addr.
readpkt(NULL), pktlen(0),
attempt_ts(0),
net_attempt(0), net_failure(0), net_unreachable(0),
sameLAN(false), n_read_zero(0), mReadZeroTS(0),
mConnectDelay(0), mConnectTS(0),
mConnectTimeout(0), mTimeoutTS(0), mLinkMgr(lm)
@ -151,7 +150,6 @@ pqissl::pqissl(pqissllistener *l, PQInterface *parent, p3LinkMgr *lm)
int pqissl::connect(struct sockaddr_in raddr)
{
// reset failures
net_failure = 0;
remote_addr = raddr;
remote_addr.sin_family = AF_INET;
@ -709,8 +707,6 @@ int pqissl::Initiate_Connection()
//reset();
waiting = WAITING_FAIL_INTERFACE;
// removing unreachables...
//net_unreachable |= net_attempt;
return -1;
}
@ -923,8 +919,6 @@ int pqissl::Basic_Connection_Complete()
//reset();
waiting = WAITING_FAIL_INTERFACE;
// removing unreachables...
//net_unreachable |= net_attempt;
return -1;
}

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

@ -28,6 +28,8 @@
#ifndef MRK_PQI_SSL_HEADER
#define MRK_PQI_SSL_HEADER
#include "util/rswin.h"
#include <openssl/ssl.h>
// operating system specific network header.
@ -114,7 +116,7 @@ virtual bool cansend();
virtual int close(); /* BinInterface version of reset() */
virtual std::string gethash(); /* not used here */
virtual bool bandwidthLimited() { return true ; } // replace by !sameLAN to avoid bandwidth limiting on lAN
virtual bool bandwidthLimited() { return true ; } // replace by !sameLAN to avoid bandwidth limiting on LAN
protected:
// A little bit of information to describe
@ -179,13 +181,6 @@ virtual int net_internal_fcntl_nonblock(int fd) { return unix_fcntl_nonblock(fd)
int attempt_ts;
// Some flags to indicate
// the status of the various interfaces
// (local), (server)
unsigned int net_attempt;
unsigned int net_failure;
unsigned int net_unreachable;
bool sameLAN; /* flag use to allow high-speed transfers */
int n_read_zero; /* a counter to determine if the connection is really dead */

1
libretroshare/src/pqi/pqissltunnel.h
View File

@ -28,6 +28,7 @@
#ifndef MRK_PQI_SSL_TUNNEL_HEADER
#define MRK_PQI_SSL_TUNNEL_HEADER
#include "util/rswin.h"
#include <openssl/ssl.h>

25
libretroshare/src/pqi/pqissludp.cc
View File

@ -245,7 +245,24 @@ int pqissludp::Initiate_Connection()
}
else if (mConnectFlags & RS_CB_FLAG_MODE_UDP_RELAY)
{
std::cerr << "Calling tou_connect_via_relay(";
std::cerr << mConnectSrcAddr << ",";
std::cerr << mConnectProxyAddr << ",";
std::cerr << remote_addr << ")" << std::endl;
tou_connect_via_relay(sockfd, &(mConnectSrcAddr), &(mConnectProxyAddr), &(remote_addr));
/*** It seems that the UDP Layer sees x 1.2 the traffic of the SSL layer.
* We need to compensate somewhere... we drop the maximum traffic to 75% of limit
* to allow for extra lost packets etc.
* NB: If we have a lossy UDP transmission - re-transmission could cause excessive data to
* exceed the limit... This is difficult to account for without hacking the TcpOnUdp layer.
* If it is noticed as a problem - we'll deal with it then
*/
#define UDP_RELAY_TRANSPORT_OVERHEAD_FACTOR (0.7)
parent()->setRateCap( UDP_RELAY_TRANSPORT_OVERHEAD_FACTOR * mConnectBandwidth / 1000.0,
UDP_RELAY_TRANSPORT_OVERHEAD_FACTOR * mConnectBandwidth / 1000.0); // Set RateCap.
}
if (0 != err)
@ -273,7 +290,6 @@ int pqissludp::Initiate_Connection()
// Then send unreachable message.
waiting = WAITING_FAIL_INTERFACE;
net_unreachable |= net_attempt;
}
out << "Error: Connection Failed: " << tou_err;
@ -359,8 +375,6 @@ int pqissludp::Basic_Connection_Complete()
out2 << " - " << socket_errorType(err);
rslog(RSL_DEBUG_BASIC, pqissludpzone, out2.str());
net_unreachable |= net_attempt;
reset();
// Then send unreachable message.
@ -470,6 +484,7 @@ bool pqissludp::connect_parameter(uint32_t type, uint32_t value)
rslog(RSL_WARNING, pqissludpzone, out.str());
mConnectPeriod = value;
std::cerr << out.str() << std::endl;
return true;
}
else if (type == NET_PARAM_CONNECT_FLAGS)
@ -479,6 +494,7 @@ bool pqissludp::connect_parameter(uint32_t type, uint32_t value)
rslog(RSL_WARNING, pqissludpzone, out.str());
mConnectFlags = value;
std::cerr << out.str() << std::endl;
return true;
}
else if (type == NET_PARAM_CONNECT_BANDWIDTH)
@ -488,6 +504,7 @@ bool pqissludp::connect_parameter(uint32_t type, uint32_t value)
rslog(RSL_WARNING, pqissludpzone, out.str());
mConnectBandwidth = value;
std::cerr << out.str() << std::endl;
return true;
}
return pqissl::connect_parameter(type, value);
@ -495,8 +512,6 @@ bool pqissludp::connect_parameter(uint32_t type, uint32_t value)
bool pqissludp::connect_additional_address(uint32_t type, struct sockaddr_in *addr)
{
struct sockaddr_in mConnectProxyAddr;
struct sockaddr_in mConnectSrcAddr;
if (type == NET_PARAM_CONNECT_PROXY)
{
std::ostringstream out;

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

@ -28,6 +28,8 @@
#ifndef MRK_PQI_SSL_UDP_HEADER
#define MRK_PQI_SSL_UDP_HEADER
#include "util/rswin.h"
#include <openssl/ssl.h>
// operating system specific network header.

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

@ -33,6 +33,8 @@
/******************** notify of new Cert **************************/
#include "util/rswin.h"
#include <openssl/evp.h>
#include <openssl/x509.h>
#include <openssl/ssl.h>

44
libretroshare/src/retroshare/rspeers.h
View File

@ -77,6 +77,47 @@ const int RS_PEER_CERT_CLEANING_CODE_NO_BEGIN_TAG = 0x02 ;
const int RS_PEER_CERT_CLEANING_CODE_NO_END_TAG = 0x03 ;
const int RS_PEER_CERT_CLEANING_CODE_NO_CHECKSUM = 0x04 ;
/* LinkType Flags */
// CONNECTION
const uint32_t RS_NET_CONN_TRANS_MASK = 0x0000ffff;
const uint32_t RS_NET_CONN_TRANS_TCP_MASK = 0x0000000f;
const uint32_t RS_NET_CONN_TRANS_TCP_UNKNOWN = 0x00000001;
const uint32_t RS_NET_CONN_TRANS_TCP_LOCAL = 0x00000002;
const uint32_t RS_NET_CONN_TRANS_TCP_EXTERNAL = 0x00000004;
const uint32_t RS_NET_CONN_TRANS_UDP_MASK = 0x000000f0;
const uint32_t RS_NET_CONN_TRANS_UDP_UNKNOWN = 0x00000010;
const uint32_t RS_NET_CONN_TRANS_UDP_DIRECT = 0x00000020;
const uint32_t RS_NET_CONN_TRANS_UDP_PROXY = 0x00000040;
const uint32_t RS_NET_CONN_TRANS_UDP_RELAY = 0x00000080;
const uint32_t RS_NET_CONN_TRANS_OTHER_MASK = 0x00000f00;
const uint32_t RS_NET_CONN_TRANS_TUNNEL = 0x00000100;
const uint32_t RS_NET_CONN_TRANS_UNKNOWN = 0x00001000;
const uint32_t RS_NET_CONN_SPEED_MASK = 0x000f0000;
const uint32_t RS_NET_CONN_SPEED_UNKNOWN = 0x00000000;
const uint32_t RS_NET_CONN_SPEED_TRICKLE = 0x00010000;
const uint32_t RS_NET_CONN_SPEED_LOW = 0x00020000;
const uint32_t RS_NET_CONN_SPEED_NORMAL = 0x00040000;
const uint32_t RS_NET_CONN_SPEED_HIGH = 0x00080000;
const uint32_t RS_NET_CONN_QUALITY_MASK = 0x00f00000;
const uint32_t RS_NET_CONN_QUALITY_UNKNOWN = 0x00000000;
// THIS INFO MUST BE SUPPLIED BY PEERMGR....
const uint32_t RS_NET_CONN_TYPE_MASK = 0x0f000000;
const uint32_t RS_NET_CONN_TYPE_UNKNOWN = 0x00000000;
const uint32_t RS_NET_CONN_TYPE_ACQUAINTANCE = 0x01000000;
const uint32_t RS_NET_CONN_TYPE_FRIEND = 0x02000000;
const uint32_t RS_NET_CONN_TYPE_SERVER = 0x04000000;
const uint32_t RS_NET_CONN_TYPE_CLIENT = 0x08000000;
/* Groups */
#define RS_GROUP_ID_FRIENDS "Friends"
#define RS_GROUP_ID_FAMILY "Family"
@ -143,6 +184,9 @@ class RsPeerDetails
std::string connectStateString; /* Additional string like ip address */
uint32_t connectPeriod;
bool foundDHT;
/* linkType */
uint32_t linkType;
};
class RsGroupInfo

2
libretroshare/src/rsserver/p3peers.cc
View File

@ -391,7 +391,7 @@ bool p3Peers::getPeerDetails(const std::string &id, RsPeerDetails &d)
if (pcs.state & RS_PEER_S_UNREACHABLE)
d.state |= RS_PEER_STATE_UNREACHABLE;
d.linkType = pcs.linkType;
/* Finally determine AutoConnect Status */
d.foundDHT = pcs.dht.found;

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

@ -313,6 +313,21 @@ void RsInit::InitRsConfig()
//setZoneLevel(PQL_DEBUG_BASIC, 49787); // pqissllistener
}
/********
* LOCALNET_TESTING - allows port restrictions
*
* #define LOCALNET_TESTING 1
*
********/
#ifdef LOCALNET_TESTING
std::string portRestrictions;
bool doPortRestrictions = false;
#endif
/******************************** WINDOWS/UNIX SPECIFIC PART ******************/
#ifndef WINDOWS_SYS
@ -395,7 +410,11 @@ int RsInit::InitRetroShare(int argcIgnored, char **argvIgnored, bool strictCheck
/* getopt info: every availiable option is listed here. if it is followed by a ':' it
needs an argument. If it is followed by a '::' the argument is optional.
*/
#ifdef LOCALNET_TESTING
while((c = getopt(argc, argv,"hesamui:p:c:w:l:d:U:r:R:")) != -1)
#else
while((c = getopt(argc, argv,"hesamui:p:c:w:l:d:U:r:")) != -1)
#endif
{
switch (c)
{
@ -470,6 +489,14 @@ int RsInit::InitRetroShare(int argcIgnored, char **argvIgnored, bool strictCheck
std::cerr << "Opt for RetroShare link";
std::cerr << std::endl;
break;
#ifdef LOCALNET_TESTING
case 'R':
portRestrictions = optarg;
doPortRestrictions = true;
std::cerr << "Opt for Port Restrictions";
std::cerr << std::endl;
break;
#endif
case 'h':
std::cerr << "Help: " << std::endl;
std::cerr << "The commandline options are for retroshare-nogui, a headless server in a shell, or systems without QT." << std::endl << std::endl;
@ -486,6 +513,9 @@ int RsInit::InitRetroShare(int argcIgnored, char **argvIgnored, bool strictCheck
std::cerr << "-e Use a forwarded external Port" << std::endl ;
std::cerr << "-U [User Name/GPG id/SSL id] Sets Account to Use, Useful when Autologin is enabled." << std::endl;
std::cerr << "-r link Use RetroShare link." << std::endl;
#ifdef LOCALNET_TESTING
std::cerr << "-R <lport-uport> Port Restrictions." << std::endl;
#endif
exit(1);
break;
default:
@ -1891,7 +1921,35 @@ int RsServer::StartupRetroShare()
struct sockaddr_in tmpladdr;
sockaddr_clear(&tmpladdr);
tmpladdr.sin_port = htons(RsInitConfig::port);
#ifdef LOCALNET_TESTING
rsUdpStack *mDhtStack = new rsUdpStack(UDP_TEST_RESTRICTED_LAYER, tmpladdr);
/* parse portRestrictions */
unsigned int lport, uport;
if (doPortRestrictions)
{
if (2 == sscanf(portRestrictions.c_str(), "%u-%u", &lport, &uport))
{
std::cerr << "Adding Port Restriction (" << lport << "-" << uport << ")";
std::cerr << std::endl;
}
else
{
std::cerr << "Failed to parse Port Restrictions ... exiting";
std::cerr << std::endl;
exit(1);
}
RestrictedUdpLayer *url = (RestrictedUdpLayer *) mDhtStack->getUdpLayer();
url->addRestrictedPortRange(lport, uport);
}
#else
rsUdpStack *mDhtStack = new rsUdpStack(tmpladdr);
#endif
#ifdef RS_USE_BITDHT
@ -1948,6 +2006,10 @@ int RsServer::StartupRetroShare()
mDhtStunner->setTargetStunPeriod(300); /* slow (5mins) */
mDhtStack->addReceiver(mDhtStunner);
#ifdef LOCALNET_TESTING
mDhtStunner->SetAcceptLocalNet();
#endif
// NEXT BITDHT.
p3BitDht *mBitDht = new p3BitDht(ownId, mLinkMgr, mNetMgr, mDhtStack, bootstrapfile);
/* install external Pointer for Interface */
@ -1972,14 +2034,38 @@ int RsServer::StartupRetroShare()
struct sockaddr_in sndladdr;
sockaddr_clear(&sndladdr);
uint16_t rndport = MIN_RANDOM_PORT + RSRandom::random_u32() % (MAX_RANDOM_PORT - MIN_RANDOM_PORT);
#ifdef LOCALNET_TESTING
// HACK Proxy Port near Dht Port - For Relay Testing.
uint16_t rndport = RsInitConfig::port + 3;
sndladdr.sin_port = htons(rndport);
#else
uint16_t rndport = MIN_RANDOM_PORT + RSRandom::random_u32() % (MAX_RANDOM_PORT - MIN_RANDOM_PORT);
#endif
#ifdef LOCALNET_TESTING
rsFixedUdpStack *mProxyStack = new rsFixedUdpStack(UDP_TEST_RESTRICTED_LAYER, sndladdr);
/* portRestrictions already parsed */
if (doPortRestrictions)
{
RestrictedUdpLayer *url = (RestrictedUdpLayer *) mProxyStack->getUdpLayer();
url->addRestrictedPortRange(lport, uport);
}
#else
rsFixedUdpStack *mProxyStack = new rsFixedUdpStack(sndladdr);
#endif
// FIRSTLY THE PROXY STUNNER.
UdpStunner *mProxyStunner = new UdpStunner(mProxyStack);
mProxyStunner->setTargetStunPeriod(300); /* slow (5mins) */
mProxyStack->addReceiver(mProxyStunner);
#ifdef LOCALNET_TESTING
mProxyStunner->SetAcceptLocalNet();
#endif
// FINALLY THE PROXY UDP CONNECTIONS
udpReceivers[RSUDP_TOU_RECVER_PROXY_IDX] = new UdpPeerReceiver(mProxyStack); /* PROXY Connections (Alt UDP Port) */

151
libretroshare/src/tcponudp/udprelay.cc
View File

@ -27,7 +27,8 @@
#include <iostream>
/*
* #define DEBUG_UDP_RELAY 1
* #define DEBUG_UDP_RELAY 1
* #define DEBUG_UDP_RELAY_PKTS 1
*/
//#define DEBUG_UDP_RELAY 1
@ -42,7 +43,11 @@ int displayUdpRelayPacketHeader(const void *data, const int size);
/****************** UDP RELAY STUFF **********/
#define MAX_RELAY_UDP_PACKET_SIZE 1024
// This packet size must be able to handle TcpStream Packets.
// At the moment, they can be 1000 + 20 for TcpOnUdp ... + 16 => 1036 minimal size.
// See Notes in tcpstream.h for more info
#define MAX_RELAY_UDP_PACKET_SIZE (1400 + 20 + 16)
UdpRelayReceiver::UdpRelayReceiver(UdpPublisher *pub)
:UdpSubReceiver(pub), udppeerMtx("UdpSubReceiver"), relayMtx("UdpSubReceiver")
@ -85,15 +90,19 @@ int UdpRelayReceiver::addUdpPeer(UdpPeer *peer, UdpRelayAddrSet *endPoints,
bool ok = (it == mStreams.end());
if (!ok)
{
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpPeerReceiver::addUdpPeer() ERROR Peer already exists!" << std::endl;
#endif
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::addUdpPeer() ERROR Peer already exists!" << std::endl;
#endif
return 0;
}
/* setup a peer */
UdpRelayEnd ure(endPoints, proxyaddr);
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::addUdpPeer() Installing UdpRelayEnd: " << ure << std::endl;
#endif
mStreams[realPeerAddr] = ure;
}
@ -102,11 +111,12 @@ int UdpRelayReceiver::addUdpPeer(UdpPeer *peer, UdpRelayAddrSet *endPoints,
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpPeerReceiver::addUdpPeer() Just installing UdpPeer!" << std::endl;
std::cerr << "UdpRelayReceiver::addUdpPeer() Installing UdpPeer" << std::endl;
#endif
/* just overwrite */
mPeers[realPeerAddr] = peer;
}
return 1;
@ -131,6 +141,9 @@ int UdpRelayReceiver::removeUdpPeer(UdpPeer *peer)
found = true;
realPeerAddr = it->first;
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::removeUdpPeer() removing UdpPeer" << std::endl;
#endif
break;
}
}
@ -138,6 +151,9 @@ int UdpRelayReceiver::removeUdpPeer(UdpPeer *peer)
if (!found)
{
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::removeUdpPeer() Warning: Failed to find UdpPeer" << std::endl;
#endif
return 0;
}
@ -154,6 +170,9 @@ int UdpRelayReceiver::removeUdpPeer(UdpPeer *peer)
else
{
/* ERROR */
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::removeUdpPeer() ERROR failed to find Mapping" << std::endl;
#endif
}
}
return 1;
@ -193,46 +212,80 @@ int UdpRelayReceiver::getRelayProxies(std::list<UdpRelayProxy> &relayProxies)
int UdpRelayReceiver::checkRelays()
{
#ifdef DEBUG_UDP_RELAY
// As this locks - must be out of the Mutex.
status(std::cerr);
#endif
RsStackMutex stack(relayMtx); /********** LOCK MUTEX *********/
/* iterate through the Relays */
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::checkRelays()";
std::cerr << std::endl;
#endif
std::list<UdpRelayAddrSet> eraseList;
std::map<UdpRelayAddrSet, UdpRelayProxy>::iterator rit;
time_t now = time(NULL);
#define BANDWIDTH_FILTER_K (0.8)
for(rit = mRelays.begin(); rit != mRelays.end(); rit++)
{
/* calc bandwidth */
rit->second.mBandwidth = rit->second.mDataSize / (float) (now - rit->second.mLastBandwidthTS);
//rit->second.mBandwidth = rit->second.mDataSize / (float) (now - rit->second.mLastBandwidthTS);
// Switch to a Low-Pass Filter to average it out.
float instantBandwidth = rit->second.mDataSize / (float) (now - rit->second.mLastBandwidthTS);
rit->second.mBandwidth *= (BANDWIDTH_FILTER_K);
rit->second.mBandwidth += (1.0 - BANDWIDTH_FILTER_K) * instantBandwidth;
rit->second.mDataSize = 0;
rit->second.mLastBandwidthTS = now;
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::checkRelays()";
std::cerr << "Relay: " << rit->first;
std::cerr << " using bandwidth: " << rit->second.mBandwidth;
std::cerr << std::endl;
#endif
// ONLY A WARNING.
#ifdef DEBUG_UDP_RELAY
if (instantBandwidth > rit->second.mBandwidthLimit)
{
std::cerr << "UdpRelayReceiver::checkRelays() ";
std::cerr << "Warning instantBandwidth: " << instantBandwidth;
std::cerr << " Exceeding Limit: " << rit->second.mBandwidthLimit;
std::cerr << " for Relay: " << rit->first;
std::cerr << std::endl;
}
#endif
if (rit->second.mBandwidth > rit->second.mBandwidthLimit)
{
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::checkRelays() ";
std::cerr << "Dropping Relay due to excessive Bandwidth: " << rit->second.mBandwidth;
std::cerr << " Exceeding Limit: " << rit->second.mBandwidthLimit;
std::cerr << " Relay: " << rit->first;
std::cerr << std::endl;
#endif
/* if exceeding bandwidth -> drop */
eraseList.push_back(rit->first);
}
else if (now - rit->second.mLastTS > RELAY_TIMEOUT)
{
#ifdef DEBUG_UDP_RELAY
/* if haven't transmitted for ages -> drop */
std::cerr << "UdpRelayReceiver::checkRelays() ";
std::cerr << "Dropping Relay due to Timeout: " << rit->first;
std::cerr << std::endl;
#endif
eraseList.push_back(rit->first);
}
else
@ -254,11 +307,13 @@ int UdpRelayReceiver::checkRelays()
}
if (now - rit->second.mStartTS > lifetime)
{
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::checkRelays() ";
std::cerr << "Dropping Relay due to Passing Lifetime Limit: " << lifetime;
std::cerr << " for class: " << rit->second.mRelayClass;
std::cerr << " Relay: " << rit->first;
std::cerr << std::endl;
#endif
eraseList.push_back(rit->first);
}
@ -270,6 +325,7 @@ int UdpRelayReceiver::checkRelays()
{
removeUdpRelay_relayLocked(&(*it));
}
return 1;
}
@ -551,6 +607,16 @@ int UdpRelayReceiver::RelayStatus(std::ostream &out)
out << "\tDataSize: " << rit->second.mDataSize;
out << "\tLastBandwidthTS: " << rit->second.mLastBandwidthTS;
}
out << "ClassLimits:" << std::endl;
for(int i = 0; i < UDP_RELAY_NUM_CLASS; i++)
{
out << "ClassLimit[" << i << "] = " << mClassLimit[i] << std::endl;
out << "ClassCount[" << i << "] = " << mClassCount[i] << std::endl;
out << "ClassBandwidth[" << i << "] = " << mClassBandwidth[i] << std::endl;
out << std::endl;
}
return 1;
}
@ -562,20 +628,45 @@ int UdpRelayReceiver::status(std::ostream &out)
RelayStatus(out);
RsStackMutex stack(relayMtx); /********** LOCK MUTEX *********/
out << "UdpRelayReceiver::Connections:" << std::endl;
std::map<struct sockaddr_in, UdpRelayEnd>::iterator pit;
for(pit = mStreams.begin(); pit != mStreams.end(); pit++)
{
out << "\t" << pit->first << " : " << pit->second;
out << std::endl;
RsStackMutex stack(relayMtx); /********** LOCK MUTEX *********/
out << "UdpRelayReceiver::Connections:" << std::endl;
std::map<struct sockaddr_in, UdpRelayEnd>::iterator pit;
for(pit = mStreams.begin(); pit != mStreams.end(); pit++)
{
out << "\t" << pit->first << " : " << pit->second;
out << std::endl;
}
}
UdpPeersStatus(out);
return 1;
}
int UdpRelayReceiver::UdpPeersStatus(std::ostream &out)
{
RsStackMutex stack(udppeerMtx); /********** LOCK MUTEX *********/
/* iterate through the Relays */
out << "UdpRelayReceiver::UdpPeersStatus()";
out << std::endl;
std::map<struct sockaddr_in, UdpPeer *>::iterator pit;
for(pit = mPeers.begin(); pit != mPeers.end(); pit++)
{
out << "UdpPeer for: " << pit->first;
out << " is: " << pit->second;
out << std::endl;
}
return 1;
}
#define UDP_RELAY_HEADER_SIZE 16
/* higher level interface */
@ -585,7 +676,7 @@ int UdpRelayReceiver::recvPkt(void *data, int size, struct sockaddr_in &from)
(void) from;
/* print packet information */
#ifdef DEBUG_UDP_RELAY
#ifdef DEBUG_UDP_RELAY_PKTS
std::cerr << "UdpRelayReceiver::recvPkt(" << size << ") from: " << from;
std::cerr << std::endl;
displayUdpRelayPacketHeader(data, size);
@ -594,7 +685,7 @@ int UdpRelayReceiver::recvPkt(void *data, int size, struct sockaddr_in &from)
if (!isUdpRelayPacket(data, size))
{
#ifdef DEBUG_UDP_RELAY
#ifdef DEBUG_UDP_RELAY_PKTS
std::cerr << "UdpRelayReceiver::recvPkt() is Not RELAY Pkt";
std::cerr << std::endl;
#endif
@ -617,11 +708,11 @@ int UdpRelayReceiver::recvPkt(void *data, int size, struct sockaddr_in &from)
if (rit != mRelays.end())
{
/* we are the relay */
#ifdef DEBUG_UDP_RELAY
#ifdef DEBUG_UDP_RELAY_PKTS
std::cerr << "UdpRelayReceiver::recvPkt() We are the Relay. Passing onto: ";
std::cerr << rit->first.mDestAddr;
std::cerr << std::endl;
#endif
#endif
/* do accounting */
rit->second.mLastTS = time(NULL);
rit->second.mDataSize += size;
@ -642,11 +733,11 @@ int UdpRelayReceiver::recvPkt(void *data, int size, struct sockaddr_in &from)
if (pit != mPeers.end())
{
/* we are the end-point */
#ifdef DEBUG_UDP_RELAY
#ifdef DEBUG_UDP_RELAY_PKTS
std::cerr << "UdpRelayReceiver::recvPkt() Sending to UdpPeer: ";
std::cerr << pit->first;
std::cerr << std::endl;
#endif
#endif
/* remove the header */
void *pktdata = (void *) (((uint8_t *) data) + UDP_RELAY_HEADER_SIZE);
int pktsize = size - UDP_RELAY_HEADER_SIZE;
@ -657,10 +748,10 @@ int UdpRelayReceiver::recvPkt(void *data, int size, struct sockaddr_in &from)
else
{
/* packet undersized */
#ifdef DEBUG_UDP_RELAY
//#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::recvPkt() ERROR Packet Undersized";
std::cerr << std::endl;
#endif
//#endif
}
return 1;
}
@ -668,10 +759,10 @@ int UdpRelayReceiver::recvPkt(void *data, int size, struct sockaddr_in &from)
}
/* unknown */
#ifdef DEBUG_UDP_RELAY
//#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::recvPkt() Peer Unknown!";
std::cerr << std::endl;
#endif
//#endif
return 0;
}
@ -695,6 +786,10 @@ int UdpRelayReceiver::sendPkt(const void *data, int size, const struct sockaddr_
return 0;
}
#ifdef DEBUG_UDP_RELAY_PKTS
std::cerr << "UdpRelayReceiver::sendPkt() to Relay: " << it->second;
std::cerr << std::endl;
#endif
/* add a header to packet */
int finalPktSize = createRelayUdpPacket(data, size, mTmpSendPkt, MAX_RELAY_UDP_PACKET_SIZE, &(it->second));
@ -755,6 +850,7 @@ int displayUdpRelayPacketHeader(const void *data, const int size)
std::cerr << out.str();
std::cerr << std::endl;
return 1;
}
#endif
@ -800,6 +896,9 @@ int createRelayUdpPacket(const void *data, const int size, void *newpkt, int new
{
std::cerr << "createRelayUdpPacket() ERROR invalid size";
std::cerr << std::endl;
std::cerr << "Incoming DataSize: " << size << " + Header: " << UDP_RELAY_HEADER_SIZE;
std::cerr << " > " << newsize;
std::cerr << std::endl;
return 0;
}
uint8_t *header = (uint8_t *) newpkt;

7
libretroshare/src/tcponudp/udprelay.h
View File

@ -110,9 +110,9 @@ std::ostream &operator<<(std::ostream &out, const UdpRelayEnd &ure);
//#define UDP_RELAY_LIFETIME_FOF 360 // 6 minutes.
//#define UDP_RELAY_LIFETIME_FRIENDS 720 // 12 minutes.
#define UDP_RELAY_LIFETIME_GENERAL 1800 // 30 minutes
#define UDP_RELAY_LIFETIME_FOF 3600 // 1 Hour.
#define UDP_RELAY_LIFETIME_FRIENDS 7200 // 2 Hour.
#define UDP_RELAY_LIFETIME_GENERAL 3600 // 1 hour (chosen so we at least transfer 1 or 2 meg at lowest speed)
#define UDP_RELAY_LIFETIME_FOF 7200 // 2 Hours.
#define UDP_RELAY_LIFETIME_FRIENDS 14400 // 4 Hours.
#define STD_RELAY_TTL 64
@ -157,6 +157,7 @@ virtual int recvPkt(void *data, int size, struct sockaddr_in &from);
virtual int sendPkt(const void *data, int size, const struct sockaddr_in &to, int ttl);
int status(std::ostream &out);
int UdpPeersStatus(std::ostream &out);
private:

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

@ -72,8 +72,6 @@ class TouStunPeer
* #define UDPSTUN_ALLOW_LOCALNET 1
*/
#define UDPSTUN_ALLOW_LOCALNET 1
class UdpStunner: public UdpSubReceiver
{
public:

4
libretroshare/src/zeroconf/p3zeroconf.cc
View File

@ -124,9 +124,7 @@ bool p3ZeroConf::getActive()
bool p3ZeroConf::getNetworkStats(uint32_t &netsize, uint32_t &localnetsize)
{
//netsize = mUdpBitDht->statsNetworkSize();
//localnetsize = mUdpBitDht->statsBDVersionSize();
return true;
return false; // Cannot provide Network Stats.
}
void p3ZeroConf::createTxtRecord()