Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-10-01 02:35:48 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleaned up rsPeers to remove 10 minute reconnect. The reconnect was caused by

Browse Source 
the periodical call of cleanupUsedLocation, which was reloading all the GPG Keys - for each cleanup Key.
This required cleaning up various bits (AuthGPG, rsPeers, p3Disc).

 * moved rsPeer::cleanUnusedLocations => p3PeerMgr::removeUnusedLocations();
 	- made the function light-weight, no loading of GPG Keys.
 * moved getSSLCertsFromGPG() fn from rsPeers => p3PeerMgr
 * added p3PeerMgr::removeAllFriendLocations() to cleanup when removing a GPG Friend.
 * cleaned up rsPeers, made addFriend() / removeFriend() universal functions.
 * remove bool   p3Peers::setAcceptToConnectGPGCertificate(const std::string &gpg_id, bool acceptance)
 * removed all Dummy SSL Ids. - There is no need for this!
 * Major changes to p3disc to correct FLAWED logic.  (needs more testing).
 * removed as many dependancies on retroshare/rspeer.h as possible.
 * changed p3turtle dependancy on rsPeers ==> mLinkMgr.
 * added p3LinkMgr::getPeerName() and p3PeerMgr::getPeerName()
 * added return 1 to pqissllistener::closeConnection().
 * removed unused code from AuthGPG().
 * removed storeAllKeys() calls in AuthGPG::AllowConnection().



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@4542 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2011-08-07 21:11:00 +00:00
parent 80629c5d9b
commit 8e3e7d5209
20 changed files with 1000 additions and 673 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
libretroshare/src/pqi/authgpg.cc
View File

@ -25,8 +25,9 @@
*/ */
#include "authgpg.h" #include "authgpg.h"
#include "retroshare/rsiface.h" #include "retroshare/rsiface.h" // For rsicontrol.
#include "retroshare/rsinit.h" #include "retroshare/rspeers.h" // For RsPeerDetails.
#include <util/rsdir.h> #include <util/rsdir.h>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
@ -64,18 +65,10 @@ AuthGPG *AuthGPG::getAuthGPG()
} }
/* Turn a set of parameters into a string */ /* Turn a set of parameters into a string */
#if 0
static std::string setKeyPairParams(bool useRsa, unsigned int blen,
std::string name, std::string comment, std::string email);
#endif
static std::string setKeyPairParams(bool useRsa, unsigned int blen, static std::string setKeyPairParams(bool useRsa, unsigned int blen,
std::string name, std::string comment, std::string email, std::string name, std::string comment, std::string email,
std::string inPassphrase); std::string inPassphrase);
#ifdef UNUSED_CODE
static gpgme_key_t getKey(gpgme_ctx_t, std::string, std::string, std::string);
#endif
static gpg_error_t keySignCallback(void *, gpgme_status_code_t, \ static gpg_error_t keySignCallback(void *, gpgme_status_code_t, \
const char *, int); const char *, int);
@ -152,15 +145,6 @@ AuthGPGimpl::AuthGPGimpl()
gpgme_set_locale(NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL)); gpgme_set_locale(NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif #endif
#ifndef WINDOWS_SYS
/* setup the engine (gpg2) */
// if (GPG_ERR_NO_ERROR != gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP, "/usr/bin/gpg2", NULL))
// {
// std::cerr << "Error creating Setting engine" << std::endl;
// return;
// }
#endif
if (GPG_ERR_NO_ERROR != gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP)) if (GPG_ERR_NO_ERROR != gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP))
{ {
std::cerr << "Error check engine version" << std::endl; std::cerr << "Error check engine version" << std::endl;
@ -995,12 +979,6 @@ bool AuthGPGimpl::VerifySignature(const void *data, int datalen, const void *sig
RsStackMutex stack(gpgMtxEngine); /******* LOCKED ******/ RsStackMutex stack(gpgMtxEngine); /******* LOCKED ******/
// if(siglen==73)
// {
// //std::cerr << "Reducing to 72 to overcome an old bug." << std::endl ;
// siglen=72 ;
// }
if (GPG_ERR_NO_ERROR != gpgme_data_new_from_mem(&gpgmeData, (const char *) data, datalen, 1)) if (GPG_ERR_NO_ERROR != gpgme_data_new_from_mem(&gpgmeData, (const char *) data, datalen, 1))
{ {
std::cerr << "Error create Data" << std::endl; std::cerr << "Error create Data" << std::endl;
@ -1515,25 +1493,24 @@ bool AuthGPGimpl::LoadCertificateFromString(const std::string &str, std::string
/*************************************/ /*************************************/
/* These take PGP Ids */ /* These take PGP Ids */
bool AuthGPGimpl::setAcceptToConnectGPGCertificate(const std::string &gpg_id, bool acceptance) bool AuthGPGimpl::AllowConnection(const std::string &gpg_id, bool accept)
{ {
#ifdef GPG_DEBUG #ifdef GPG_DEBUG
std::cerr << "AuthGPGimpl::markGPGCertificateAsFriends(" << gpg_id << ")" << std::endl; std::cerr << "AuthGPGimpl::AllowConnection(" << gpg_id << ")" << std::endl;
#endif #endif
/* reload stuff now ... */ /* Was a "Reload Certificates" here -> be shouldn't be needed -> and very expensive, try without. */
storeAllKeys();
{ {
RsStackMutex stack(gpgMtxData); RsStackMutex stack(gpgMtxData);
certmap::iterator it; certmap::iterator it;
if (mKeyList.end() == (it = mKeyList.find(gpg_id))) { if (mKeyList.end() == (it = mKeyList.find(gpg_id)))
{
return false; return false;
} }
it->second.accept_connection = acceptance; it->second.accept_connection = accept;
mAcceptToConnectMap[gpg_id] = acceptance; mAcceptToConnectMap[gpg_id] = accept;
} }
storeAllKeys();
IndicateConfigChanged(); IndicateConfigChanged();
@ -1730,69 +1707,6 @@ int AuthGPGimpl::privateTrustCertificate(const std::string &id, int trustlvl)
return 1; return 1;
} }
/* This function to print Data */
#if 0
void showData(gpgme_data_t dh)
{
#define BUF_SIZE 512
char buf[BUF_SIZE + 1];
int ret;
ret = gpgme_data_seek (dh, 0, SEEK_SET);
if (ret)
{
std::cerr << "Fail data seek" << std::endl;
// fail_if_err (gpgme_err_code_from_errno (errno));
}
while ((ret = gpgme_data_read (dh, buf, BUF_SIZE)) > 0)
fwrite (buf, ret, 1, stdout);
if (ret < 0)
{
std::cerr << "Fail data seek" << std::endl;
//fail_if_err (gpgme_err_code_from_errno (errno));
}
}
#endif
#if 0
static std::string setKeyPairParams(bool useRsa, unsigned int blen,
std::string name, std::string comment, std::string email)
{
std::ostringstream params;
params << "<GnupgKeyParms format=\"internal\">"<< std::endl;
if (useRsa)
{
params << "Key-Type: RSA"<< std::endl;
if (blen < 1024)
{
#ifdef GPG_DEBUG
std::cerr << "Weak Key... strengthing..."<< std::endl;
#endif
blen = 1024;
}
blen = ((blen / 512) * 512); /* make multiple of 512 */
params << "Key-Length: "<< blen << std::endl;
}
else
{
params << "Key-Type: DSA"<< std::endl;
params << "Key-Length: 1024"<< std::endl;
params << "Subkey-Type: ELG-E"<< std::endl;
params << "Subkey-Length: 1024"<< std::endl;
}
params << "Name-Real: "<< name << std::endl;
params << "Name-Comment: "<< comment << std::endl;
params << "Name-Email: "<< email << std::endl;
params << "Expire-Date: 0"<< std::endl;
params << "</GnupgKeyParms>"<< std::endl;
return params.str();
}
#endif
static std::string setKeyPairParams(bool useRsa, unsigned int blen, static std::string setKeyPairParams(bool useRsa, unsigned int blen,
std::string name, std::string comment, std::string email, std::string name, std::string comment, std::string email,
std::string inPassphrase) std::string inPassphrase)
@ -2357,16 +2271,25 @@ bool AuthGPGimpl::saveList(bool& cleanup, std::list<RsItem*>& lst)
// Now save config for network digging strategies // Now save config for network digging strategies
RsConfigKeyValueSet *vitem = new RsConfigKeyValueSet ; RsConfigKeyValueSet *vitem = new RsConfigKeyValueSet ;
std::map<std::string, bool>::iterator mapIt; std::map<std::string, bool>::iterator mapIt;
for (mapIt = mAcceptToConnectMap.begin(); mapIt != mAcceptToConnectMap.end(); mapIt++) { for (mapIt = mAcceptToConnectMap.begin(); mapIt != mAcceptToConnectMap.end(); mapIt++)
if (mapIt->first == mOwnGpgId) { {
// skip our own id.
if (mapIt->first == mOwnGpgId)
{
continue; continue;
} }
// skip if we dont accept them.
if (!(mapIt->second))
{
continue;
}
RsTlvKeyValue kv; RsTlvKeyValue kv;
kv.key = mapIt->first; kv.key = mapIt->first;
#ifdef GPG_DEBUG #ifdef GPG_DEBUG
std::cerr << "AuthGPGimpl::saveList() called (mapIt->second) : " << (mapIt->second) << std::endl ; std::cerr << "AuthGPGimpl::saveList() called (mapIt->second) : " << (mapIt->second) << std::endl ;
#endif #endif
kv.value = (mapIt->second)?"TRUE":"FALSE" ; kv.value = "TRUE";
vitem->tlvkvs.pairs.push_back(kv) ; vitem->tlvkvs.pairs.push_back(kv) ;
} }
lst.push_back(vitem); lst.push_back(vitem);
@ -2385,10 +2308,11 @@ bool AuthGPGimpl::loadList(std::list<RsItem*>& load)
RsStackMutex stack(gpgMtxData); /******* LOCKED ******/ RsStackMutex stack(gpgMtxData); /******* LOCKED ******/
/* load the list of accepted gpg keys */ /* load the list of accepted gpg keys */
std::list<RsItem *>::iterator it; std::list<RsItem *>::iterator it;
for(it = load.begin(); it != load.end(); it++) { for(it = load.begin(); it != load.end(); it++)
{
RsConfigKeyValueSet *vitem = dynamic_cast<RsConfigKeyValueSet *>(*it); RsConfigKeyValueSet *vitem = dynamic_cast<RsConfigKeyValueSet *>(*it);
if(vitem)
if(vitem) { {
#ifdef GPG_DEBUG #ifdef GPG_DEBUG
std::cerr << "AuthGPGimpl::loadList() General Variable Config Item:" << std::endl; std::cerr << "AuthGPGimpl::loadList() General Variable Config Item:" << std::endl;
vitem->print(std::cerr, 10); vitem->print(std::cerr, 10);
@ -2396,18 +2320,22 @@ bool AuthGPGimpl::loadList(std::list<RsItem*>& load)
#endif #endif
std::list<RsTlvKeyValue>::iterator kit; std::list<RsTlvKeyValue>::iterator kit;
for(kit = vitem->tlvkvs.pairs.begin(); kit != vitem->tlvkvs.pairs.end(); kit++) { for(kit = vitem->tlvkvs.pairs.begin(); kit != vitem->tlvkvs.pairs.end(); kit++)
if (kit->key == mOwnGpgId) { {
if (kit->key == mOwnGpgId)
{
continue; continue;
} }
mAcceptToConnectMap[kit->key] = (kit->value == "TRUE");
//set the gpg key /* only allowed in the map if the gpg certificate exists */
certmap::iterator it; certmap::iterator it;
if (mKeyList.end() != (it = mKeyList.find(kit->key))) { if (mKeyList.end() != (it = mKeyList.find(kit->key)))
{
#ifdef GPG_DEBUG #ifdef GPG_DEBUG
std::cerr << "AuthGPGimpl::loadList() setting accept to : " << (kit->value == "TRUE"); std::cerr << "AuthGPGimpl::loadList() setting accept to : " << (kit->value == "TRUE");
std::cerr << " for gpg key id : " << kit->key << std::endl; std::cerr << " for gpg key id : " << kit->key << std::endl;
#endif #endif
mAcceptToConnectMap[kit->key] = (kit->value == "TRUE");
it->second.accept_connection = (kit->value == "TRUE"); it->second.accept_connection = (kit->value == "TRUE");
} }
} }

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

@ -43,7 +43,7 @@
#include <openssl/ssl.h> #include <openssl/ssl.h>
#include <openssl/evp.h> #include <openssl/evp.h>
#include "util/rsthreads.h" #include "util/rsthreads.h"
#include "retroshare/rspeers.h" //#include "retroshare/rspeers.h"
#include <string> #include <string>
#include <list> #include <list>
#include <set> #include <set>
@ -52,6 +52,8 @@
#define MAX_GPG_SIGNATURE_SIZE 4096 #define MAX_GPG_SIGNATURE_SIZE 4096
class RsPeerDetails;
/*! /*!
* gpgcert is the identifier for a person. * gpgcert is the identifier for a person.
* It is a wrapper class for a GPGme OpenPGP certificate. * It is a wrapper class for a GPGme OpenPGP certificate.
@ -225,7 +227,9 @@ virtual std::string SaveCertificateToString(const std::string &id,bool include_s
* done in gpgroot already. * done in gpgroot already.
* *
****/ ****/
virtual bool setAcceptToConnectGPGCertificate(const std::string &gpg_id, bool acceptance) = 0; //don't act on the gpg key, use a seperate set
virtual bool AllowConnection(const std::string &gpg_id, bool accept) = 0;
virtual bool SignCertificateLevel0(const std::string &id) = 0; virtual bool SignCertificateLevel0(const std::string &id) = 0;
virtual bool RevokeCertificate(const std::string &id) = 0; /* Particularly hard - leave for later */ virtual bool RevokeCertificate(const std::string &id) = 0; /* Particularly hard - leave for later */
//virtual bool TrustCertificateNone(std::string id) = 0; //virtual bool TrustCertificateNone(std::string id) = 0;
@ -345,7 +349,8 @@ virtual std::string SaveCertificateToString(const std::string &id,bool include_s
* done in gpgroot already. * done in gpgroot already.
* *
****/ ****/
virtual bool setAcceptToConnectGPGCertificate(const std::string &gpg_id, bool acceptance); //don't act on the gpg key, use a seperate set virtual bool AllowConnection(const std::string &gpg_id, bool accept);
virtual bool SignCertificateLevel0(const std::string &id); virtual bool SignCertificateLevel0(const std::string &id);
virtual bool RevokeCertificate(const std::string &id); /* Particularly hard - leave for later */ virtual bool RevokeCertificate(const std::string &id); /* Particularly hard - leave for later */

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

@ -37,6 +37,8 @@
#include "serialiser/rsconfigitems.h" #include "serialiser/rsconfigitems.h"
#include "util/rsdir.h" #include "util/rsdir.h"
#include "retroshare/rspeers.h" // for RsPeerDetails structure
/******************** notify of new Cert **************************/ /******************** notify of new Cert **************************/
#include "pqinotify.h" #include "pqinotify.h"

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

@ -49,7 +49,6 @@
#include "pqi/pqi_base.h" #include "pqi/pqi_base.h"
#include "pqi/pqinetwork.h" #include "pqi/pqinetwork.h"
//#include "rsiface/rspeers.h"
#include "pqi/p3cfgmgr.h" #include "pqi/p3cfgmgr.h"
typedef std::string SSL_id; typedef std::string SSL_id;

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

@ -24,7 +24,7 @@
*/ */
#include "util/rsdir.h" #include "util/rsdir.h"
#include "retroshare/rspeers.h" //#include "retroshare/rspeers.h"
#include "pqi/p3cfgmgr.h" #include "pqi/p3cfgmgr.h"
#include "pqi/authssl.h" #include "pqi/authssl.h"
#include "pqi/pqibin.h" #include "pqi/pqibin.h"

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

@ -237,6 +237,12 @@ void p3LinkMgrIMPL::getFriendList(std::list<std::string> &ssl_peers)
} }
bool p3LinkMgrIMPL::getPeerName(const std::string &ssl_id, std::string &name)
{
return mPeerMgr->getPeerName(ssl_id, name);
}
int p3LinkMgrIMPL::getFriendCount() int p3LinkMgrIMPL::getFriendCount()
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/

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

@ -169,6 +169,7 @@ virtual ~p3LinkMgr() { return; }
virtual const std::string getOwnId() = 0; virtual const std::string getOwnId() = 0;
virtual bool isOnline(const std::string &ssl_id) = 0; virtual bool isOnline(const std::string &ssl_id) = 0;
virtual void getOnlineList(std::list<std::string> &ssl_peers) = 0; virtual void getOnlineList(std::list<std::string> &ssl_peers) = 0;
virtual bool getPeerName(const std::string &ssl_id, std::string &name) = 0;
/**************** handle monitors *****************/ /**************** handle monitors *****************/
virtual void addMonitor(pqiMonitor *mon) = 0; virtual void addMonitor(pqiMonitor *mon) = 0;
@ -224,6 +225,7 @@ class p3LinkMgrIMPL: public p3LinkMgr
virtual const std::string getOwnId(); virtual const std::string getOwnId();
virtual bool isOnline(const std::string &ssl_id); virtual bool isOnline(const std::string &ssl_id);
virtual void getOnlineList(std::list<std::string> &ssl_peers); virtual void getOnlineList(std::list<std::string> &ssl_peers);
virtual bool getPeerName(const std::string &ssl_id, std::string &name);
/**************** handle monitors *****************/ /**************** handle monitors *****************/

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

@ -882,6 +882,8 @@ void p3NetMgrIMPL::netExtCheck()
if (netSetupDone) if (netSetupDone)
{ {
std::cerr << "p3NetMgrIMPL::netExtCheck() netSetupDone" << std::endl;
/* Setup NetStateBox with this info */ /* Setup NetStateBox with this info */
updateNetStateBox_startup(); updateNetStateBox_startup();

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

@ -42,7 +42,10 @@ const int p3peermgrzone = 9531;
#include "serialiser/rsconfigitems.h" #include "serialiser/rsconfigitems.h"
#include "pqi/pqinotify.h" #include "pqi/pqinotify.h"
#include "retroshare/rsiface.h"
#include "retroshare/rsiface.h" // Needed for rsicontrol (should remove this dependancy)
#include "retroshare/rspeers.h" // Needed for Group Parameters.
#include <sstream> #include <sstream>
@ -110,6 +113,7 @@ p3PeerMgrIMPL::p3PeerMgrIMPL()
mOwnState.name = AuthGPG::getAuthGPG()->getGPGOwnName(); mOwnState.name = AuthGPG::getAuthGPG()->getGPGOwnName();
mOwnState.location = AuthSSL::getAuthSSL()->getOwnLocation(); mOwnState.location = AuthSSL::getAuthSSL()->getOwnLocation();
mOwnState.netMode = RS_NET_MODE_UPNP; // Default to UPNP. mOwnState.netMode = RS_NET_MODE_UPNP; // Default to UPNP.
mOwnState.visState = 0;
lastGroupId = 1; lastGroupId = 1;
@ -156,11 +160,14 @@ void p3PeerMgrIMPL::setOwnVisState(uint32_t visState)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
std::ostringstream out;
out << "p3PeerMgr::setOwnVisState()";
out << "Existing vis: " << mOwnState.visState;
out << "Input vis: " << visState;
rslog(RSL_WARNING, p3peermgrzone, out.str());
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::setOwnVisState()"; std::cerr << out.str() << std::endl;
std::cerr << "Existing vis: " << mOwnState.visState;
std::cerr << "Input vis: " << visState;
std::cerr << std::endl;
#endif #endif
mOwnState.visState = visState; mOwnState.visState = visState;
@ -182,13 +189,13 @@ void p3PeerMgrIMPL::tick()
time_t now = time(NULL) ; time_t now = time(NULL) ;
if(now > last_friends_check + INTERVAL_BETWEEN_LOCATION_CLEANING && rsPeers != NULL) if(now - last_friends_check > INTERVAL_BETWEEN_LOCATION_CLEANING)
{ {
std::cerr << "p3PeerMgrIMPL::tick(): cleaning unused locations." << std::endl ; std::cerr << "p3PeerMgrIMPL::tick(): cleaning unused locations." << std::endl ;
rslog(RSL_WARNING, p3peermgrzone, "p3PeerMgr::tick() cleanUnusedLocations()"); rslog(RSL_WARNING, p3peermgrzone, "p3PeerMgr::tick() removeUnusedLocations()");
rsPeers->cleanUnusedLocations() ; removeUnusedLocations() ;
last_friends_check = now ; last_friends_check = now ;
} }
} }
@ -225,6 +232,23 @@ bool p3PeerMgrIMPL::isFriend(const std::string &id)
return ret; return ret;
} }
bool p3PeerMgrIMPL::getPeerName(const std::string &ssl_id, std::string &name)
{
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */
std::map<std::string, peerState>::iterator it;
it = mFriendList.find(ssl_id);
if (it == mFriendList.end())
{
return false;
}
name = it->second.name + " (" + it->second.location + ")";
return true;
}
bool p3PeerMgrIMPL::getFriendNetStatus(const std::string &id, peerState &state) bool p3PeerMgrIMPL::getFriendNetStatus(const std::string &id, peerState &state)
{ {
@ -998,6 +1022,14 @@ bool p3PeerMgrIMPL::setLocation(const std::string &id, const std::string &loc
bool p3PeerMgrIMPL::setVisState(const std::string &id, uint32_t visState) bool p3PeerMgrIMPL::setVisState(const std::string &id, uint32_t visState)
{ {
{
std::ostringstream out;
out << "p3PeerMgr::setVisState(";
out << id;
out << ", " << visState << ")";
rslog(RSL_WARNING, p3peermgrzone, out.str());
}
if (id == AuthSSL::getAuthSSL()->OwnId()) if (id == AuthSSL::getAuthSSL()->OwnId())
{ {
setOwnVisState(visState); setOwnVisState(visState);
@ -1630,3 +1662,118 @@ bool p3PeerMgrIMPL::assignPeersToGroup(const std::string &groupId, const std::li
return changed; return changed;
} }
/**********************************************************************
**********************************************************************
******************** Stuff moved from p3peers ************************
**********************************************************************
**********************************************************************/
bool p3PeerMgrIMPL::removeAllFriendLocations(const std::string &gpgid)
{
std::list<std::string> sslIds;
if (!getAssociatedPeers(gpgid, sslIds))
{
return false;
}
std::list<std::string>::iterator it;
for(it = sslIds.begin(); it != sslIds.end(); it++)
{
removeFriend(*it);
}
return true;
}
bool p3PeerMgrIMPL::getAssociatedPeers(const std::string &gpg_id, std::list<std::string> &ids)
{
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
#ifdef P3PEERS_DEBUG
std::cerr << "p3PeerMgr::getAssociatedPeers() for id : " << gpg_id << std::endl;
#endif
int count = 0;
std::map<std::string, peerState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{
if (it->second.gpg_id == gpg_id)
{
count++;
ids.push_back(it->first);
#ifdef P3PEERS_DEBUG
std::cerr << "p3PeerMgr::getAssociatedPeers() found ssl id : " << it->first << std::endl;
#endif
}
}
return (count > 0);
}
/* This only removes SSL certs, that are old... Can end up with no Certs per GPG Id
* We are removing the concept of a "DummyId" - There is no need for it.
*/
bool isDummyFriend(std::string id)
{
bool ret = (id.substr(0,5) == "dummy");
return ret;
}
#define VERY_OLD_PEER (30 * 24 * 3600) // 30 days.
bool p3PeerMgrIMPL::removeUnusedLocations()
{
std::list<std::string> toRemove;
{
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
#ifdef P3PEERS_DEBUG
std::cerr << "p3PeerMgr::removeUnusedLocations()" << std::endl;
#endif
time_t now = time(NULL);
std::map<std::string, peerState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{
if (now - it->second.lastcontact > VERY_OLD_PEER)
{
toRemove.push_back(it->first);
#ifdef P3PEERS_DEBUG
std::cerr << "p3PeerMgr::removeUnusedLocations() removing Old SSL Id: " << it->first << std::endl;
#endif
}
if (isDummyFriend(it->first))
{
toRemove.push_back(it->first);
#ifdef P3PEERS_DEBUG
std::cerr << "p3PeerMgr::removeUnusedLocations() removing Dummy Id: " << it->first << std::endl;
#endif
}
}
}
std::list<std::string>::iterator it;
for(it = toRemove.begin(); it != toRemove.end(); it++)
{
removeFriend(*it);
}
}

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

@ -127,6 +127,8 @@ virtual bool removeFriend(const std::string &ssl_id) = 0;
virtual bool isFriend(const std::string &ssl_id) = 0; virtual bool isFriend(const std::string &ssl_id) = 0;
virtual bool getAssociatedPeers(const std::string &gpg_id, std::list<std::string> &ids) = 0;
virtual bool removeAllFriendLocations(const std::string &gpgid) = 0;
/******************** Groups **********************/ /******************** Groups **********************/
@ -178,6 +180,8 @@ virtual bool getOwnNetStatus(peerState &state) = 0;
virtual bool getFriendNetStatus(const std::string &id, peerState &state) = 0; virtual bool getFriendNetStatus(const std::string &id, peerState &state) = 0;
virtual bool getOthersNetStatus(const std::string &id, peerState &state) = 0; virtual bool getOthersNetStatus(const std::string &id, peerState &state) = 0;
virtual bool getPeerName(const std::string &ssl_id, std::string &name) = 0;
/************* DEPRECIATED FUNCTIONS (TO REMOVE) ********/ /************* DEPRECIATED FUNCTIONS (TO REMOVE) ********/
@ -208,6 +212,9 @@ virtual bool removeFriend(const std::string &ssl_id);
virtual bool isFriend(const std::string &ssl_id); virtual bool isFriend(const std::string &ssl_id);
virtual bool getAssociatedPeers(const std::string &gpg_id, std::list<std::string> &ids);
virtual bool removeAllFriendLocations(const std::string &gpgid);
/******************** Groups **********************/ /******************** Groups **********************/
/* This is solely used by p3peers - makes sense */ /* This is solely used by p3peers - makes sense */
@ -257,6 +264,8 @@ virtual bool getOwnNetStatus(peerState &state);
virtual bool getFriendNetStatus(const std::string &id, peerState &state); virtual bool getFriendNetStatus(const std::string &id, peerState &state);
virtual bool getOthersNetStatus(const std::string &id, peerState &state); virtual bool getOthersNetStatus(const std::string &id, peerState &state);
virtual bool getPeerName(const std::string &ssl_id, std::string &name);
/************* DEPRECIATED FUNCTIONS (TO REMOVE) ********/ /************* DEPRECIATED FUNCTIONS (TO REMOVE) ********/
@ -282,8 +291,13 @@ int getConnectAddresses(const std::string &id,
struct sockaddr_in &lAddr, struct sockaddr_in &eAddr, struct sockaddr_in &lAddr, struct sockaddr_in &eAddr,
pqiIpAddrSet &histAddrs, std::string &dyndns); pqiIpAddrSet &histAddrs, std::string &dyndns);
protected: protected:
/* Internal Functions */ /* Internal Functions */
bool removeUnusedLocations();
void printPeerLists(std::ostream &out); void printPeerLists(std::ostream &out);
protected: protected:

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

@ -493,6 +493,8 @@ int pqissllistenbase::closeConnection(int fd, SSL *ssl)
/************************** WINDOWS/UNIX SPECIFIC PART ******************/ /************************** WINDOWS/UNIX SPECIFIC PART ******************/
// free connection. // free connection.
SSL_free(ssl); SSL_free(ssl);
return 1;
} }

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

@ -186,14 +186,12 @@ virtual bool getGPGSignedList(std::list<std::string> &gpg_ids) = 0;//friend
virtual bool getGPGValidList(std::list<std::string> &gpg_ids) = 0; virtual bool getGPGValidList(std::list<std::string> &gpg_ids) = 0;
virtual bool getGPGAllList(std::list<std::string> &gpg_ids) = 0; virtual bool getGPGAllList(std::list<std::string> &gpg_ids) = 0;
virtual bool getGPGDetails(const std::string &gpg_id, RsPeerDetails &d) = 0; virtual bool getGPGDetails(const std::string &gpg_id, RsPeerDetails &d) = 0;
virtual bool getSSLChildListOfGPGId(const std::string &gpg_id, std::list<std::string> &ssl_ids) = 0; virtual bool getAssociatedSSLIds(const std::string &gpg_id, std::list<std::string> &ids) = 0;
/* Add/Remove Friends */ /* Add/Remove Friends */
virtual bool addFriend(const std::string &ssl_id, const std::string &gpg_id) = 0; virtual bool addFriend(const std::string &ssl_id, const std::string &gpg_id) = 0;
virtual bool addDummyFriend(const std::string &gpg_id) = 0; //we want to add a empty ssl friend for this gpg id
virtual bool isDummyFriend(const std::string &ssl_id) = 0;
virtual bool removeFriend(const std::string &ssl_or_gpg_id) = 0; virtual bool removeFriend(const std::string &ssl_or_gpg_id) = 0;
virtual bool cleanUnusedLocations() = 0 ; virtual bool removeFriendLocation(const std::string &sslId) = 0;
/* Network Stuff */ /* Network Stuff */
virtual bool connectAttempt(const std::string &ssl_id) = 0; virtual bool connectAttempt(const std::string &ssl_id) = 0;
@ -221,7 +219,7 @@ virtual bool cleanCertificate(const std::string &certstr, std::string &cleanCert
virtual bool saveCertificateToFile(const std::string &id, const std::string &fname) = 0; virtual bool saveCertificateToFile(const std::string &id, const std::string &fname) = 0;
virtual std::string saveCertificateToString(const std::string &id) = 0; virtual std::string saveCertificateToString(const std::string &id) = 0;
virtual bool setAcceptToConnectGPGCertificate(const std::string &gpg_id, bool acceptance) = 0; //virtual bool setAcceptToConnectGPGCertificate(const std::string &gpg_id, bool acceptance) = 0;
virtual bool signGPGCertificate(const std::string &gpg_id) = 0; virtual bool signGPGCertificate(const std::string &gpg_id) = 0;
virtual bool trustGPGCertificate(const std::string &gpg_id, uint32_t trustlvl) = 0; virtual bool trustGPGCertificate(const std::string &gpg_id, uint32_t trustlvl) = 0;

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

@ -250,6 +250,199 @@ bool p3Peers::isFriend(const std::string &ssl_id)
} }
/* There are too many dependancies of this function
* to shift it immeidately
*/
bool p3Peers::getPeerDetails(const std::string &id, RsPeerDetails &d)
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::getPeerDetails() called for id : " << id << std::endl;
#endif
// NOW Only for SSL Details.
std::string sOwnId = AuthSSL::getAuthSSL()->OwnId();
peerState ps;
if (id == sOwnId)
{
mPeerMgr->getOwnNetStatus(ps);
ps.gpg_id = AuthGPG::getAuthGPG()->getGPGOwnId();
}
else
{
if (!mPeerMgr->getFriendNetStatus(id, ps))
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::getPeerDetails() ERROR not an SSL Id: " << id << std::endl;
#endif
d.isOnlyGPGdetail = false;
return getGPGDetails(id, d);
}
}
/* get from gpg (first), to fill in the sign and trust details */
/* don't retrun now, we've got fill in the ssl and connection info */
getGPGDetails(ps.gpg_id, d);
d.isOnlyGPGdetail = false;
//get the ssl details
d.id = id;
d.location = ps.location;
/* generate */
d.authcode = "AUTHCODE";
/* fill from pcs */
d.localAddr = rs_inet_ntoa(ps.localaddr.sin_addr);
d.localPort = ntohs(ps.localaddr.sin_port);
d.extAddr = rs_inet_ntoa(ps.serveraddr.sin_addr);
d.extPort = ntohs(ps.serveraddr.sin_port);
d.dyndns = ps.dyndns;
d.lastConnect = ps.lastcontact;
d.connectPeriod = 0;
std::list<pqiIpAddress>::iterator it;
for(it = ps.ipAddrs.mLocal.mAddrs.begin();
it != ps.ipAddrs.mLocal.mAddrs.end(); it++)
{
std::ostringstream toto;
toto << ntohs(it->mAddr.sin_port) << " " << (time(NULL) - it->mSeenTime) << " sec";
d.ipAddressList.push_back("L:" + std::string(rs_inet_ntoa(it->mAddr.sin_addr)) + ":" + toto.str());
}
for(it = ps.ipAddrs.mExt.mAddrs.begin();
it != ps.ipAddrs.mExt.mAddrs.end(); it++)
{
std::ostringstream toto;
toto << ntohs(it->mAddr.sin_port) << " " << (time(NULL) - it->mSeenTime) << " sec";
d.ipAddressList.push_back("E:" + std::string(rs_inet_ntoa(it->mAddr.sin_addr)) + ":" + toto.str());
}
switch(ps.netMode & RS_NET_MODE_ACTUAL)
{
case RS_NET_MODE_EXT:
d.netMode = RS_NETMODE_EXT;
break;
case RS_NET_MODE_UPNP:
d.netMode = RS_NETMODE_UPNP;
break;
case RS_NET_MODE_UDP:
d.netMode = RS_NETMODE_UDP;
break;
case RS_NET_MODE_UNREACHABLE:
case RS_NET_MODE_UNKNOWN:
default:
d.netMode = RS_NETMODE_UNREACHABLE;
break;
}
if (ps.netMode & RS_NET_MODE_TRY_EXT)
{
d.tryNetMode = RS_NETMODE_EXT;
}
else if (ps.netMode & RS_NET_MODE_TRY_UPNP)
{
d.tryNetMode = RS_NETMODE_UPNP;
}
else
{
d.tryNetMode = RS_NETMODE_UDP;
}
d.visState = 0;
if (!(ps.visState & RS_VIS_STATE_NODISC))
{
d.visState |= RS_VS_DISC_ON;
}
if (!(ps.visState & RS_VIS_STATE_NODHT))
{
d.visState |= RS_VS_DHT_ON;
}
/* Translate */
peerConnectState pcs;
if (!mLinkMgr->getFriendNetStatus(id, pcs))
{
std::cerr << "p3Peers::getPeerDetails() ERROR No Link Information : " << id << std::endl;
return true;
}
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::getPeerDetails() got a SSL id and is returning SSL and GPG details for id : " << id << std::endl;
#endif
d.state = 0;
if (pcs.state & RS_PEER_S_FRIEND)
d.state |= RS_PEER_STATE_FRIEND;
if (pcs.state & RS_PEER_S_ONLINE)
d.state |= RS_PEER_STATE_ONLINE;
if (pcs.state & RS_PEER_S_CONNECTED)
d.state |= RS_PEER_STATE_CONNECTED;
if (pcs.state & RS_PEER_S_UNREACHABLE)
d.state |= RS_PEER_STATE_UNREACHABLE;
/* Finally determine AutoConnect Status */
d.foundDHT = pcs.dht.found;
d.connectState = 0;
d.connectStateString.clear();
if (pcs.inConnAttempt)
{
if (pcs.currentConnAddrAttempt.type & RS_NET_CONN_TUNNEL) {
d.connectState = RS_PEER_CONNECTSTATE_TRYING_TUNNEL;
} else if (pcs.currentConnAddrAttempt.type & RS_NET_CONN_TCP_ALL) {
d.connectState = RS_PEER_CONNECTSTATE_TRYING_TCP;
std::ostringstream str;
str << rs_inet_ntoa(pcs.currentConnAddrAttempt.addr.sin_addr) << ":" << ntohs(pcs.currentConnAddrAttempt.addr.sin_port);
d.connectStateString = str.str();
} else if (pcs.currentConnAddrAttempt.type & RS_NET_CONN_UDP_ALL) {
d.connectState = RS_PEER_CONNECTSTATE_TRYING_UDP;
std::ostringstream str;
str << rs_inet_ntoa(pcs.currentConnAddrAttempt.addr.sin_addr) << ":" << ntohs(pcs.currentConnAddrAttempt.addr.sin_port);
d.connectStateString = str.str();
}
}
else if (pcs.state & RS_PEER_S_CONNECTED)
{
if (pcs.connecttype == RS_NET_CONN_TCP_ALL)
{
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_TCP;
}
else if (pcs.connecttype == RS_NET_CONN_UDP_ALL)
{
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UDP;
}
else if (pcs.connecttype == RS_NET_CONN_TUNNEL)
{
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_TUNNEL;
}
else
{
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UNKNOWN;
}
}
return true;
}
#if 0
bool p3Peers::getPeerDetails(const std::string &id, RsPeerDetails &d) bool p3Peers::getPeerDetails(const std::string &id, RsPeerDetails &d)
{ {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
@ -433,6 +626,7 @@ bool p3Peers::getPeerDetails(const std::string &id, RsPeerDetails &d)
return true; return true;
} }
#endif
std::string p3Peers::getGPGName(const std::string &gpg_id) std::string p3Peers::getGPGName(const std::string &gpg_id)
@ -453,20 +647,23 @@ std::string p3Peers::getPeerName(const std::string &ssl_or_gpg_id)
std::cerr << "p3Peers::getPeerName() " << ssl_or_gpg_id << std::endl; std::cerr << "p3Peers::getPeerName() " << ssl_or_gpg_id << std::endl;
#endif #endif
std::string name; std::string name;
if (ssl_or_gpg_id == AuthSSL::getAuthSSL()->OwnId()) { if (ssl_or_gpg_id == AuthSSL::getAuthSSL()->OwnId())
{
return AuthGPG::getAuthGPG()->getGPGOwnName(); return AuthGPG::getAuthGPG()->getGPGOwnName();
} }
peerState pcs;
if (mPeerMgr->getFriendNetStatus(ssl_or_gpg_id, pcs)) { if (mPeerMgr->getPeerName(ssl_or_gpg_id, name))
{
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::getPeerName() got a ssl id. Name is : " << pcs.name << std::endl; std::cerr << "p3Peers::getPeerName() got a ssl id. Name is : " << name << std::endl;
#endif #endif
return pcs.name; return name;
} }
return AuthGPG::getAuthGPG()->getGPGName(ssl_or_gpg_id); return AuthGPG::getAuthGPG()->getGPGName(ssl_or_gpg_id);
} }
bool p3Peers::getGPGAllList(std::list<std::string> &ids) bool p3Peers::getGPGAllList(std::list<std::string> &ids)
{ {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
@ -509,107 +706,16 @@ bool p3Peers::getGPGAcceptedList(std::list<std::string> &ids)
return true; return true;
} }
bool p3Peers::getSSLChildListOfGPGId(const std::string &gpg_id, std::list<std::string> &ids)
bool p3Peers::getAssociatedSSLIds(const std::string &gpg_id, std::list<std::string> &ids)
{ {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::getSSLChildListOfGPGId() for id : " << gpg_id << std::endl; std::cerr << "p3Peers::getAssociatedSSLIds() for id : " << gpg_id << std::endl;
#endif #endif
ids.clear();
if (gpg_id == "" ) { return mPeerMgr->getAssociatedPeers(gpg_id, ids);
return false;
}
//let's roll throush the friends
std::list<std::string> friendsIds;
mLinkMgr->getFriendList(friendsIds);
peerState pcs;
for (std::list<std::string>::iterator it = friendsIds.begin(); it != friendsIds.end(); it++)
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::getSSLChildListOfGPGId() iterating over friends id : " << *it << std::endl;
#endif
if (mPeerMgr->getFriendNetStatus(*it, pcs) && pcs.gpg_id == gpg_id) {
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::getSSLChildListOfGPGId() adding ssl id : " << pcs.id << std::endl;
#endif
ids.push_back(pcs.id);
}
}
return true;
} }
bool p3Peers::cleanUnusedLocations()
{
// Obtain all current locations of each GPG friend.
//
std::map<std::string,std::list<peerState> > friends_info ;
std::list<std::string> friendSSLIds ;
mLinkMgr->getFriendList(friendSSLIds);
for(std::list<std::string>::const_iterator it(friendSSLIds.begin());it!=friendSSLIds.end();++it)
{
peerState pcs;
if(mPeerMgr->getFriendNetStatus(*it, pcs))
friends_info[pcs.gpg_id].push_back(pcs) ;
}
// Now sort them out
//
std::cerr << "Examining Old/Unused locations." << std::endl ;
time_t now = time(NULL) ;
std::list<std::string> locations_to_remove ;
for(std::map<std::string,std::list<peerState> >::iterator it(friends_info.begin());it!=friends_info.end();++it)
{
std::list<peerState>& locations_list(it->second) ;
int size = locations_list.size() ;
std::cerr << " GPG id: " << it->first << std::endl ;
for(std::list<peerState>::const_iterator itloc(locations_list.begin());itloc!=locations_list.end();++itloc)
std::cerr << " Location " << (*itloc).id << ", last contact " << now - (*itloc).lastcontact << " seconds ago" << std::endl ;
// Remove any location that is dummy. Update the list, such that we only look into non dummy friends later.
//
for(std::list<peerState>::iterator itloc(locations_list.begin());itloc!=locations_list.end();)
if(size > 1 && isDummyFriend((*itloc).id))
{
locations_to_remove.push_back((*itloc).id) ;
--size ;
std::cerr << " Removing dummy location: " << (*itloc).id << std::endl ;
std::list<peerState>::iterator tmp(itloc) ;
++tmp ;
locations_list.erase(itloc) ;
itloc=tmp ;
}
else
++itloc ;
for(std::list<peerState>::const_iterator itloc(locations_list.begin());itloc!=locations_list.end();++itloc)
if(size > 1 && now > (*itloc).lastcontact + MAX_TIME_KEEP_LOCATION_WITHOUT_CONTACT)
{
locations_to_remove.push_back((*itloc).id) ;
--size ;
std::cerr << " Removing unused location: " << (*itloc).id << std::endl ;
}
}
std::cerr << "Now removing unused locations:" << std::endl ;
for(std::list<std::string>::const_iterator it(locations_to_remove.begin());it!=locations_to_remove.end();++it)
{
std::cerr << " Removing unused friend location " << *it << std::endl ;
removeFriend(*it) ;
}
return true ;
}
bool p3Peers::getGPGDetails(const std::string &id, RsPeerDetails &d) bool p3Peers::getGPGDetails(const std::string &id, RsPeerDetails &d)
{ {
@ -656,74 +762,117 @@ std::string p3Peers::getGPGId(const std::string &sslid_or_gpgid)
} }
/* These Functions are now the only way to authorize a new gpg user...
* if we are passed a ssl_id, then use it... otherwise just auth gpg_id
*/
/* Add/Remove Friends */ /* Add/Remove Friends */
bool p3Peers::addFriend(const std::string &id, const std::string &gpg_id) bool p3Peers::addFriend(const std::string &ssl_id, const std::string &gpg_id)
{ {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::addFriend() with : id : " << id << "; gpg_id : " << gpg_id << std::endl; std::cerr << "p3Peers::addFriend() with : id : " << id << "; gpg_id : " << gpg_id << std::endl;
#endif #endif
if (id == gpg_id || id == "") { if (AuthGPG::getAuthGPG()->isGPGId(gpg_id))
return addDummyFriend(gpg_id);
} else {
return mPeerMgr->addFriend(id, gpg_id);
}
}
bool p3Peers::addDummyFriend(const std::string &gpg_id)
{ {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::addDummyFriend() called" << std::endl; std::cerr << "p3Peers::addFriend() Authorising GPG Id: " << gpg_id << std::endl;
#endif #endif
std::string dummy_ssl_id = "dummy"+ gpg_id; if (AuthGPG::getAuthGPG()->AllowConnection(gpg_id, true))
//check if this gpg_id already got a dummy friend {
if (!mPeerMgr->isFriend(dummy_ssl_id)) {
return mPeerMgr->addFriend(dummy_ssl_id, gpg_id);
} else {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::addDummyFriend() dummy friend already exists for gpg_id : " << gpg_id << std::endl; std::cerr << "p3Peers::addFriend() Authorization OK." << std::endl;
#endif
}
else
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::addFriend() Authorization FAILED." << std::endl;
#endif #endif
return false; return false;
} }
} }
else
bool p3Peers::isDummyFriend(const std::string &ssl_id) {
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::isDummyFriend() called" << std::endl;
#endif
RsPeerDetails details;
bool ret = false;
if (getPeerDetails(ssl_id, details)) {
ret = (details.id == ("dummy" + details.gpg_id));
} else {
ret = (ssl_id.substr(0,5) == "dummy");
}
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::isDummyFriend() return : " << ret << std::endl;
#endif
return ret;
}
bool p3Peers::removeFriend(const std::string &ssl_or_gpgid)
{ {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::removeFriend() " << ssl_or_gpgid << std::endl; std::cerr << "p3Peers::addFriend() Bad gpg_id : " << gpg_id << std::endl;
#endif
if (ssl_or_gpgid == AuthGPG::getAuthGPG()->getGPGOwnId()) {
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::removeFriend() fail : we're not going to remove our own GPG id." << std::endl;
#endif #endif
return false; return false;
} }
//will remove if it's a gpg id
AuthGPG::getAuthGPG()->setAcceptToConnectGPGCertificate(ssl_or_gpgid, false);
if (ssl_id == gpg_id || ssl_id == "")
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::addFriend() WARNING id is NULL or gpgId" << std::endl;
#endif
return true;
}
/* otherwise - we install as ssl_id. */
return mPeerMgr->addFriend(ssl_id, gpg_id);
}
bool p3Peers::removeFriendLocation(const std::string &sslId)
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::removeFriendLocation() " << sslId << std::endl;
#endif
//will remove if it's a ssl id //will remove if it's a ssl id
mPeerMgr->removeFriend(ssl_or_gpgid); mPeerMgr->removeFriend(sslId);
return true; return true;
} }
bool p3Peers::removeFriend(const std::string &gpgId)
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::removeFriend() " << gpgId << std::endl;
#endif
if (gpgId == AuthGPG::getAuthGPG()->getGPGOwnId()) {
std::cerr << "p3Peers::removeFriend() ERROR we're not going to remove our own GPG id." << std::endl;
return false;
}
if (AuthGPG::getAuthGPG()->isGPGId(gpgId))
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::removeFriend() Removing GPG Id: " << gpgId << std::endl;
#endif
if (AuthGPG::getAuthGPG()->AllowConnection(gpgId, false))
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::removeFriend() OK." << std::endl;
#endif
mPeerMgr->removeAllFriendLocations(gpgId);
return true;
}
else
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::removeFriend() FAILED." << std::endl;
#endif
mPeerMgr->removeAllFriendLocations(gpgId);
return false;
}
}
else
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::removeFriend() Not GPG Id: " << gpg_id << std::endl;
#endif
return removeFriendLocation(gpgId);
}
return false;
}
/* Network Stuff */ /* Network Stuff */
bool p3Peers::connectAttempt(const std::string &id) bool p3Peers::connectAttempt(const std::string &id)
{ {
@ -1187,27 +1336,10 @@ bool p3Peers::signGPGCertificate(const std::string &id)
#endif #endif
AuthGPG::getAuthGPG()->setAcceptToConnectGPGCertificate(id, true); AuthGPG::getAuthGPG()->AllowConnection(id, true);
return AuthGPG::getAuthGPG()->SignCertificateLevel0(id); return AuthGPG::getAuthGPG()->SignCertificateLevel0(id);
} }
bool p3Peers::setAcceptToConnectGPGCertificate(const std::string &gpg_id, bool acceptance)
{
#ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::setAcceptToConnectGPGCertificate() called with gpg_id : " << gpg_id << ", acceptance : " << acceptance << std::endl;
#endif
if (gpg_id != "" && acceptance == false) {
//remove the friends from the connect manager
std::list<std::string> sslFriends;
this->getSSLChildListOfGPGId(gpg_id, sslFriends);
for (std::list<std::string>::iterator it = sslFriends.begin(); it != sslFriends.end(); it++) {
mPeerMgr->removeFriend(*it);
}
return AuthGPG::getAuthGPG()->setAcceptToConnectGPGCertificate(gpg_id, acceptance);
}
return AuthGPG::getAuthGPG()->setAcceptToConnectGPGCertificate(gpg_id, acceptance);
}
bool p3Peers::trustGPGCertificate(const std::string &id, uint32_t trustlvl) bool p3Peers::trustGPGCertificate(const std::string &id, uint32_t trustlvl)
{ {

13
libretroshare/src/rsserver/p3peers.h
View File

@ -46,6 +46,8 @@ virtual bool OthersChanged();
/* Peer Details (Net & Auth) */ /* Peer Details (Net & Auth) */
virtual std::string getOwnId(); virtual std::string getOwnId();
virtual bool getOnlineList(std::list<std::string> &ids); virtual bool getOnlineList(std::list<std::string> &ids);
virtual bool getFriendList(std::list<std::string> &ids); virtual bool getFriendList(std::list<std::string> &ids);
//virtual bool getOthersList(std::list<std::string> &ids); //virtual bool getOthersList(std::list<std::string> &ids);
@ -56,7 +58,7 @@ virtual bool isFriend(const std::string &id);
virtual bool isGPGAccepted(const std::string &gpg_id_is_friend); // virtual bool isGPGAccepted(const std::string &gpg_id_is_friend); //
virtual std::string getGPGName(const std::string &gpg_id); virtual std::string getGPGName(const std::string &gpg_id);
virtual std::string getPeerName(const std::string &ssl_or_gpg_id); virtual std::string getPeerName(const std::string &ssl_or_gpg_id);
virtual bool getPeerDetails(const std::string &id, RsPeerDetails &d); virtual bool getPeerDetails(const std::string &ssl_or_gpg_id, RsPeerDetails &d);
/* Using PGP Ids */ /* Using PGP Ids */
virtual std::string getGPGOwnId(); virtual std::string getGPGOwnId();
@ -66,14 +68,12 @@ virtual bool getGPGSignedList(std::list<std::string> &ids);
virtual bool getGPGValidList(std::list<std::string> &ids); virtual bool getGPGValidList(std::list<std::string> &ids);
virtual bool getGPGAllList(std::list<std::string> &ids); virtual bool getGPGAllList(std::list<std::string> &ids);
virtual bool getGPGDetails(const std::string &id, RsPeerDetails &d); virtual bool getGPGDetails(const std::string &id, RsPeerDetails &d);
virtual bool getSSLChildListOfGPGId(const std::string &gpg_id, std::list<std::string> &ids); virtual bool getAssociatedSSLIds(const std::string &gpg_id, std::list<std::string> &ids);
/* Add/Remove Friends */ /* Add/Remove Friends */
virtual bool addFriend(const std::string &ssl_id, const std::string &gpg_id); virtual bool addFriend(const std::string &ssl_id, const std::string &gpg_id);
virtual bool addDummyFriend(const std::string &gpg_id); //we want to add a empty ssl friend for this gpg id virtual bool removeFriend(const std::string &ssl_or_gpgid);
virtual bool isDummyFriend(const std::string &ssl_id); virtual bool removeFriendLocation(const std::string &sslId);
virtual bool removeFriend(const std::string &ssl_id);
virtual bool cleanUnusedLocations() ;
/* Network Stuff */ /* Network Stuff */
virtual bool connectAttempt(const std::string &id); virtual bool connectAttempt(const std::string &id);
@ -103,7 +103,6 @@ virtual bool cleanCertificate(const std::string &certstr, std::string &cleanCert
virtual bool saveCertificateToFile(const std::string &id, const std::string &fname); virtual bool saveCertificateToFile(const std::string &id, const std::string &fname);
virtual std::string saveCertificateToString(const std::string &id); virtual std::string saveCertificateToString(const std::string &id);
virtual bool setAcceptToConnectGPGCertificate(const std::string &gpg_id, bool acceptance);
virtual bool signGPGCertificate(const std::string &id); virtual bool signGPGCertificate(const std::string &id);
virtual bool trustGPGCertificate(const std::string &id, uint32_t trustlvl); virtual bool trustGPGCertificate(const std::string &id, uint32_t trustlvl);

2
libretroshare/src/serialiser/rsconfigitems.cc
View File

@ -26,7 +26,7 @@
#include "serialiser/rsbaseserial.h" #include "serialiser/rsbaseserial.h"
#include "serialiser/rsconfigitems.h" #include "serialiser/rsconfigitems.h"
#include "retroshare/rspeers.h" #include "retroshare/rspeers.h" // Needed for RsGroupInfo.
/*** /***
* #define RSSERIAL_DEBUG 1 * #define RSSERIAL_DEBUG 1

549
libretroshare/src/services/p3disc.cc
View File

@ -25,7 +25,6 @@
#include "retroshare/rsiface.h" #include "retroshare/rsiface.h"
#include "retroshare/rsinit.h" /* for PGPSSL flag */
#include "retroshare/rspeers.h" #include "retroshare/rspeers.h"
#include "services/p3disc.h" #include "services/p3disc.h"
@ -74,11 +73,6 @@ const uint32_t P3DISC_FLAGS_ASK_VERSION = 0x0080;
//#define P3DISC_DEBUG 1 //#define P3DISC_DEBUG 1
/*********** NOTE ***************
*
* Only need Mutexs for neighbours information
*/
/****************************************************************************************** /******************************************************************************************
****************************** NEW DISCOVERY ******************************************* ****************************** NEW DISCOVERY *******************************************
****************************************************************************************** ******************************************************************************************
@ -94,7 +88,8 @@ p3disc::p3disc(p3PeerMgr *pm, p3LinkMgr *lm, pqipersongrp *pqih)
addSerialType(new RsDiscSerialiser()); addSerialType(new RsDiscSerialiser());
lastSentHeartbeatTime = time(NULL); mLastSentHeartbeatTime = time(NULL);
mDiscEnabled = true;
//add own version to versions map //add own version to versions map
versions[AuthSSL::getAuthSSL()->OwnId()] = RsUtil::retroshareVersion(); versions[AuthSSL::getAuthSSL()->OwnId()] = RsUtil::retroshareVersion();
@ -109,17 +104,35 @@ p3disc::p3disc(p3PeerMgr *pm, p3LinkMgr *lm, pqipersongrp *pqih)
int p3disc::tick() int p3disc::tick()
{ {
//send a heartbeat to all connected peers //send a heartbeat to all connected peers
if (time(NULL) - lastSentHeartbeatTime > HEARTBEAT_REPEAT_TIME) time_t hbTime;
{
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
hbTime = mLastSentHeartbeatTime;
}
if (time(NULL) - hbTime > HEARTBEAT_REPEAT_TIME)
{ {
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::tick() sending heartbeat to all peers" << std::endl; std::cerr << "p3disc::tick() sending heartbeat to all peers" << std::endl;
#endif #endif
lastSentHeartbeatTime = time(NULL);
std::list<std::string> peers; std::list<std::string> peers;
std::list<std::string>::const_iterator pit;
mLinkMgr->getOnlineList(peers); mLinkMgr->getOnlineList(peers);
for (std::list<std::string>::const_iterator pit = peers.begin(); pit != peers.end(); ++pit) { for (pit = peers.begin(); pit != peers.end(); ++pit)
{
sendHeartbeat(*pit); sendHeartbeat(*pit);
} }
/* check our Discovery flag */
peerState detail;
mPeerMgr->getOwnNetStatus(detail);
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
mDiscEnabled = (!(detail.visState & RS_VIS_STATE_NODISC));
mLastSentHeartbeatTime = time(NULL);
} }
return handleIncoming(); return handleIncoming();
@ -133,23 +146,6 @@ int p3disc::handleIncoming()
std::cerr << "p3disc::handleIncoming()" << std::endl; std::cerr << "p3disc::handleIncoming()" << std::endl;
#endif #endif
// if off discard item.
peerState detail;
if (!mPeerMgr->getOwnNetStatus(detail) || (detail.visState & RS_VIS_STATE_NODISC))
{
while(NULL != (item = recvItem()))
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::handleIncoming() Deleting - Cos RemoteDisc Off!" << std::endl;
item -> print(std::cerr);
std::cerr << std::endl;
#endif
delete item;
}
return 0;
}
int nhandled = 0; int nhandled = 0;
// While messages read // While messages read
while(NULL != (item = recvItem())) while(NULL != (item = recvItem()))
@ -165,36 +161,25 @@ int p3disc::handleIncoming()
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
// if discovery reply then respond if haven't already. // if discovery reply then respond if haven't already.
if (NULL != (dri = dynamic_cast<RsDiscReply *> (item))) { if (NULL != (dri = dynamic_cast<RsDiscReply *> (item)))
{
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/ recvDiscReply(dri);
/* search pending item and remove it, when already exist */
std::list<RsDiscReply*>::iterator it;
for (it = pendingDiscReplyInList.begin(); it != pendingDiscReplyInList.end(); it++) {
if ((*it)->PeerId() == dri->PeerId() && (*it)->aboutId == dri->aboutId) {
delete (*it);
pendingDiscReplyInList.erase(it);
break;
} }
} else if (NULL != (dvi = dynamic_cast<RsDiscVersion *> (item)))
{
// add item to list for later process
pendingDiscReplyInList.push_back(dri); // no delete
}
else if (NULL != (dvi = dynamic_cast<RsDiscVersion *> (item))) {
recvPeerVersionMsg(dvi); recvPeerVersionMsg(dvi);
nhandled++; nhandled++;
delete item; delete item;
} }
else if (NULL != (inf = dynamic_cast<RsDiscAskInfo *> (item))) /* Ping */ { else if (NULL != (inf = dynamic_cast<RsDiscAskInfo *> (item))) /* Ping */
{
recvAskInfo(inf); recvAskInfo(inf);
nhandled++; nhandled++;
delete item; delete item;
} }
else if (NULL != (dta = dynamic_cast<RsDiscHeartbeat *> (item))) { else if (NULL != (dta = dynamic_cast<RsDiscHeartbeat *> (item)))
{
recvHeartbeatMsg(dta); recvHeartbeatMsg(dta);
nhandled++ ; nhandled++ ;
delete item; delete item;
@ -219,6 +204,7 @@ int p3disc::handleIncoming()
/************* from pqiMonitor *******************/ /************* from pqiMonitor *******************/
void p3disc::statusChange(const std::list<pqipeer> &plist) void p3disc::statusChange(const std::list<pqipeer> &plist)
{ {
@ -268,54 +254,66 @@ void p3disc::sendAllInfoToJustConnectedPeer(const std::string &id)
std::cerr << "p3disc::sendAllInfoToJustConnectedPeer() id: " << id << std::endl; std::cerr << "p3disc::sendAllInfoToJustConnectedPeer() id: " << id << std::endl;
#endif #endif
RsPeerDetails pd;
rsPeers->getPeerDetails(id, pd);
if (pd.gpg_id != rsPeers->getGPGOwnId() && (!pd.accept_connection || !pd.ownsign) )
{
//only send info when connection is accepted and gpg key is signed or our own key
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendAllInfoToJustConnectedPeer() we're not sending the info because the destination gpg key is not signed or not accepted." << std::cerr << std::endl;
#endif
return;
}
std::list<std::string> friendIds; std::list<std::string> friendIds;
std::list<std::string>::iterator friendIdsIt; std::list<std::string>::iterator it;
std::set<std::string> gpgIds; std::set<std::string> gpgIds;
std::set<std::string>::iterator git;
rsPeers->getFriendList(friendIds); /* We send our full friends list - if we have Discovery Enabled */
if (mDiscEnabled)
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendAllInfoToJustConnectedPeer() Discovery Enabled, sending Friend List" << std::endl;
#endif
mLinkMgr->getFriendList(friendIds);
/* send them a list of all friend's details */ /* send them a list of all friend's details */
for(friendIdsIt = friendIds.begin(); friendIdsIt != friendIds.end(); friendIdsIt++) { for(it = friendIds.begin(); it != friendIds.end(); it++)
{
/* get details */ /* get details */
peerState detail; peerState detail;
if (!mPeerMgr->getFriendNetStatus(*friendIdsIt, detail)) { if (!mPeerMgr->getFriendNetStatus(*it, detail))
{
/* major error! */ /* major error! */
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendAllInfoToJustConnectedPeer() No Info, Skipping: " << *it;
std::cerr << std::endl;
#endif
continue; continue;
} }
if (!(detail.visState & RS_VIS_STATE_NODISC)) { if (!(detail.visState & RS_VIS_STATE_NODISC))
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendAllInfoToJustConnectedPeer() Adding GPGID: " << detail.gpg_id;
std::cerr << " (SSLID: " << *it << ")";
std::cerr << std::endl;
#endif
gpgIds.insert(detail.gpg_id); gpgIds.insert(detail.gpg_id);
} }
else
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendAllInfoToJustConnectedPeer() DISC OFF for GPGID: " << detail.gpg_id;
std::cerr << " (SSLID: " << *it << ")";
std::cerr << std::endl;
#endif
}
}
} }
//add own info //add own info, this info is sent whether discovery is enabled - or not.
gpgIds.insert(rsPeers->getGPGOwnId()); gpgIds.insert(rsPeers->getGPGOwnId());
{ {
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/ RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
/* append gpg id's to the sending list for the id */ /* refresh with new list */
std::list<std::string> &idList = mSendIdList[id];
std::list<std::string> &idList = sendIdList[id]; idList.clear();
for(git = gpgIds.begin(); git != gpgIds.end(); git++)
std::set<std::string>::iterator gpgIdsIt; {
for (gpgIdsIt = gpgIds.begin(); gpgIdsIt != gpgIds.end(); gpgIdsIt++) { idList.push_back(*git);
if (std::find(idList.begin(), idList.end(), *gpgIdsIt) == idList.end()) {
idList.push_back(*gpgIdsIt);
}
} }
} }
@ -326,14 +324,46 @@ void p3disc::sendAllInfoToJustConnectedPeer(const std::string &id)
void p3disc::sendJustConnectedPeerInfoToAllPeer(const std::string &connectedPeerId) void p3disc::sendJustConnectedPeerInfoToAllPeer(const std::string &connectedPeerId)
{ {
/* get a peer lists */
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendJustConnectedPeerInfoToAllPeer() connectedPeerId : " << connectedPeerId << std::endl; std::cerr << "p3disc::sendJustConnectedPeerInfoToAllPeer() connectedPeerId : " << connectedPeerId << std::endl;
#endif #endif
/* only ask info if discovery is on */
{
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
if (!mDiscEnabled)
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendJustConnectedPeerInfoToAllPeer() Disc Disabled => NULL OP" << std::endl;
#endif
return;
}
}
/* get details */
peerState detail;
if (!mPeerMgr->getFriendNetStatus(connectedPeerId, detail))
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendJustConnectedPeerInfoToAllPeer() No NetStatus => FAILED" << std::endl;
#endif
return;
}
if (detail.visState & RS_VIS_STATE_NODISC)
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendJustConnectedPeerInfoToAllPeer() Peer Disc Discable => NULL OP" << std::endl;
#endif
return;
}
std::string gpg_connectedPeerId = rsPeers->getGPGId(connectedPeerId); std::string gpg_connectedPeerId = rsPeers->getGPGId(connectedPeerId);
std::list<std::string> onlineIds; std::list<std::string> onlineIds;
/* get a peer lists */
rsPeers->getOnlineList(onlineIds); rsPeers->getOnlineList(onlineIds);
{ {
@ -341,40 +371,45 @@ void p3disc::sendJustConnectedPeerInfoToAllPeer(const std::string &connectedPeer
/* append gpg id's of all friend's to the sending list */ /* append gpg id's of all friend's to the sending list */
std::list<std::string>::iterator onlineIdsIt; std::list<std::string>::iterator it;
for (onlineIdsIt = onlineIds.begin(); onlineIdsIt != onlineIds.end(); onlineIdsIt++) { for (it = onlineIds.begin(); it != onlineIds.end(); it++)
std::list<std::string> &idList = sendIdList[*onlineIdsIt]; {
if (std::find(idList.begin(), idList.end(), gpg_connectedPeerId) == idList.end()) { std::list<std::string> &idList = mSendIdList[*it];
if (std::find(idList.begin(), idList.end(), gpg_connectedPeerId) == idList.end())
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendJustConnectedPeerInfoToAllPeer() adding to queue for: ";
std::cerr << *it << std::endl;
#endif
idList.push_back(gpg_connectedPeerId); idList.push_back(gpg_connectedPeerId);
} }
else
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendJustConnectedPeerInfoToAllPeer() already in queue for: ";
std::cerr << *it << std::endl;
#endif
} }
} }
} }
}
bool isDummyFriend(const std::string &id)
{
bool ret = (id.substr(0,5) == "dummy");
return ret;
}
/* (dest (to), source (cert)) */ /* (dest (to), source (cert)) */
RsDiscReply *p3disc::createDiscReply(const std::string &to, const std::string &about) RsDiscReply *p3disc::createDiscReply(const std::string &to, const std::string &about)
{ {
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() called. Sending details of: " << about << " to: " << to << std::endl; std::cerr << "p3disc::createDiscReply() called. Sending details of: " << about << " to: " << to << std::endl;
#endif #endif
RsPeerDetails pd;
rsPeers->getPeerDetails(to, pd);
if (pd.gpg_id != rsPeers->getGPGOwnId() && (!pd.accept_connection || !pd.ownsign) )
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() we're not sending the info because the destination gpg key is not signed or not accepted." << std::cerr << std::endl;
#endif
return NULL;
}
// if off discard item.
peerState detail;
if (!mPeerMgr->getOwnNetStatus(detail) || (detail.visState & RS_VIS_STATE_NODISC)) {
return NULL;
}
std::string aboutGpgId = rsPeers->getGPGId(about); std::string aboutGpgId = rsPeers->getGPGId(about);
if (aboutGpgId.empty()) { if (aboutGpgId.empty()) {
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
@ -383,6 +418,7 @@ RsDiscReply *p3disc::createDiscReply(const std::string &to, const std::string &a
return NULL; return NULL;
} }
// Construct a message // Construct a message
RsDiscReply *di = new RsDiscReply(); RsDiscReply *di = new RsDiscReply();
@ -393,36 +429,56 @@ RsDiscReply *p3disc::createDiscReply(const std::string &to, const std::string &a
// set the ip addresse list. // set the ip addresse list.
std::list<std::string> sslChilds; std::list<std::string> sslChilds;
rsPeers->getSSLChildListOfGPGId(aboutGpgId, sslChilds); rsPeers->getAssociatedSSLIds(aboutGpgId, sslChilds);
bool shouldWeSendGPGKey = false;//the GPG key is send only if we've got a valid friend with DISC enabled bool shouldWeSendGPGKey = false;//the GPG key is send only if we've got a valid friend with DISC enabled
std::list<std::string>::iterator sslChildIt; {
for (sslChildIt = sslChilds.begin(); sslChildIt != sslChilds.end(); sslChildIt++) RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
if(!rsPeers->isDummyFriend(*sslChildIt)) if (!mDiscEnabled)
{ {
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() Found Child SSL Id:" << *sslChildIt; std::cerr << "p3disc::createDiscReply() Disc Disabled, removing all friend SSL Ids";
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
if(sslChilds.size() == 1 || to != *sslChildIt) // We don't send info to a peer about itself, when there are more than one ssl children, sslChilds.clear();
{ // but we allow sending info about peers with the same GPG id. When there is only one ssl child, }
// we must send it to transfer the signers of the gpg key. The receiver is skipping the own id. }
std::list<std::string>::iterator it;
for (it = sslChilds.begin(); it != sslChilds.end(); it++)
{
/* skip dummy ones - until they are removed fully */
if (isDummyFriend(*it))
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() Skipping Dummy Child SSL Id:" << *it;
std::cerr << std::endl;
#endif
continue;
}
peerState detail; peerState detail;
if (!mPeerMgr->getFriendNetStatus(*sslChildIt, detail) if (!mPeerMgr->getFriendNetStatus(*it, detail)
|| detail.visState & RS_VIS_STATE_NODISC) || detail.visState & RS_VIS_STATE_NODISC)
{ {
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() Skipping cos No Details or NODISC flag"; std::cerr << "p3disc::createDiscReply() Skipping cos No Details or NODISC flag id: " << *it;
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
continue; continue;
} }
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() Found Child SSL Id:" << *it;
std::cerr << std::endl;
#endif
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() Adding Child SSL Id Details"; std::cerr << "p3disc::createDiscReply() Adding Child SSL Id Details";
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
shouldWeSendGPGKey = true; shouldWeSendGPGKey = true;
RsPeerNetItem rsPeerNetItem ; RsPeerNetItem rsPeerNetItem ;
rsPeerNetItem.clear(); rsPeerNetItem.clear();
@ -441,19 +497,15 @@ RsDiscReply *p3disc::createDiscReply(const std::string &to, const std::string &a
di->rsPeerList.push_back(rsPeerNetItem); di->rsPeerList.push_back(rsPeerNetItem);
} }
else
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() Skipping cos \"to == sslChildId\"";
std::cerr << std::endl;
#endif
}
}
//send own details //send own details
if (about == rsPeers->getGPGOwnId()) if (about == rsPeers->getGPGOwnId())
{ {
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::createDiscReply() Adding Own Id Details";
std::cerr << std::endl;
#endif
peerState detail; peerState detail;
if (mPeerMgr->getOwnNetStatus(detail)) if (mPeerMgr->getOwnNetStatus(detail))
{ {
@ -494,6 +546,16 @@ void p3disc::sendOwnVersion(std::string to)
std::cerr << "p3disc::sendOwnVersion() Sending rs version to: " << to << std::endl; std::cerr << "p3disc::sendOwnVersion() Sending rs version to: " << to << std::endl;
#endif #endif
/* only ask info if discovery is on */
if (!mDiscEnabled)
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::sendOwnVersion() Disc Disabled => NULL OP" << std::endl;
#endif
return;
}
RsDiscVersion *di = new RsDiscVersion(); RsDiscVersion *di = new RsDiscVersion();
di->PeerId(to); di->PeerId(to);
di->version = RsUtil::retroshareVersion(); di->version = RsUtil::retroshareVersion();
@ -537,9 +599,11 @@ void p3disc::askInfoToAllPeers(std::string about)
std::cerr <<"p3disc::askInfoToAllPeers() about " << about << std::endl; std::cerr <<"p3disc::askInfoToAllPeers() about " << about << std::endl;
#endif #endif
// We Still Ask even if Disc isn't Enabled... if they want to give us the info ;)
peerState connectState; peerState connectState;
if (!mPeerMgr->getFriendNetStatus(about, connectState)) // || (connectState.visState & RS_VIS_STATE_NODISC)) { if (!mPeerMgr->getFriendNetStatus(about, connectState) || (connectState.visState & RS_VIS_STATE_NODISC))
{ {
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::askInfoToAllPeers() friend disc is off, don't send the request." << std::endl; std::cerr << "p3disc::askInfoToAllPeers() friend disc is off, don't send the request." << std::endl;
@ -548,43 +612,27 @@ void p3disc::askInfoToAllPeers(std::string about)
} }
std::string aboutGpgId = rsPeers->getGPGId(about); std::string aboutGpgId = rsPeers->getGPGId(about);
if (aboutGpgId == "") { if (aboutGpgId == "")
{
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::askInfoToAllPeers() no gpg id found" << std::endl; std::cerr << "p3disc::askInfoToAllPeers() no gpg id found" << std::endl;
#endif #endif
} }
// if off discard item.
if (!mPeerMgr->getOwnNetStatus(connectState) || (connectState.visState & RS_VIS_STATE_NODISC)) {
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::askInfoToAllPeers() no gpg id found" << std::endl;
#endif
return;
}
std::list<std::string> onlineIds; std::list<std::string> onlineIds;
std::list<std::string>::iterator onlineIdsIt; std::list<std::string>::iterator it;
rsPeers->getOnlineList(onlineIds); rsPeers->getOnlineList(onlineIds);
/* ask info to trusted friends */ /* ask info to trusted friends */
for(onlineIdsIt = onlineIds.begin(); onlineIdsIt != onlineIds.end(); onlineIdsIt++) for(it = onlineIds.begin(); it != onlineIds.end(); it++)
{ {
RsPeerDetails details;
rsPeers->getPeerDetails(*onlineIdsIt, details);
if (!details.accept_connection || !details.ownsign)
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::askInfoToAllPeers() don't ask info message to untrusted peer." << std::endl;
#endif
continue;
}
RsDiscAskInfo *di = new RsDiscAskInfo(); RsDiscAskInfo *di = new RsDiscAskInfo();
di->PeerId(*onlineIdsIt); di->PeerId(*it);
di->gpg_id = about; di->gpg_id = aboutGpgId;
sendItem(di); sendItem(di);
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::askInfoToAllPeers() question sent to : " << *onlineIdsIt << std::endl; std::cerr << "p3disc::askInfoToAllPeers() question sent to : " << *it << std::endl;
#endif #endif
} }
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
@ -594,12 +642,6 @@ void p3disc::askInfoToAllPeers(std::string about)
void p3disc::recvPeerDetails(RsDiscReply *item, const std::string &certGpgId) void p3disc::recvPeerDetails(RsDiscReply *item, const std::string &certGpgId)
{ {
// discovery is only disabled for sending, not for receiving.
// // if off discard item.
// peerConnectState detail;
// if (!mConnMgr->getOwnNetStatus(detail) || (detail.visState & RS_VIS_STATE_NODISC)) {
// return;
// }
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::recvPeerFriendMsg() From: " << item->PeerId() << " About " << item->aboutId << std::endl; std::cerr << "p3disc::recvPeerFriendMsg() From: " << item->PeerId() << " About " << item->aboutId << std::endl;
@ -620,11 +662,17 @@ void p3disc::recvPeerDetails(RsDiscReply *item, const std::string &certGpgId)
bool should_notify_discovery = false ; bool should_notify_discovery = false ;
for (std::list<RsPeerNetItem>::iterator pitem = item->rsPeerList.begin(); pitem != item->rsPeerList.end(); pitem++) std::list<RsPeerNetItem>::iterator pit;
if(!rsPeers->isDummyFriend(pitem->pid)) for (pit = item->rsPeerList.begin(); pit != item->rsPeerList.end(); pit++)
{ {
bool new_info ; if(isDummyFriend(pit->pid))
addDiscoveryData(item->PeerId(), pitem->pid,rsPeers->getGPGId(item->PeerId()),item->aboutId, pitem->currentlocaladdr, pitem->currentremoteaddr, 0, time(NULL),new_info); {
continue;
}
bool new_info = false;
addDiscoveryData(item->PeerId(), pit->pid,rsPeers->getGPGId(item->PeerId()),
item->aboutId, pit->currentlocaladdr, pit->currentremoteaddr, 0, time(NULL),new_info);
if(new_info) if(new_info)
should_notify_discovery = true ; should_notify_discovery = true ;
@ -632,101 +680,83 @@ void p3disc::recvPeerDetails(RsDiscReply *item, const std::string &certGpgId)
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::recvPeerFriendMsg() Peer Config Item:" << std::endl; std::cerr << "p3disc::recvPeerFriendMsg() Peer Config Item:" << std::endl;
pitem->print(std::cerr, 10); pit->print(std::cerr, 10);
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
if (pitem->pid != rsPeers->getOwnId()) if (pit->pid != rsPeers->getOwnId())
{ {
// Apparently, the connect manager won't add a friend if the gpg id is not // Apparently, the connect manager won't add a friend if the gpg id is not
// trusted. However, this should be tested here for consistency and security // trusted. However, this should be tested here for consistency and security
// in case of modifications in mConnMgr. // in case of modifications in mConnMgr.
// //
if(AuthGPG::getAuthGPG()->isGPGAccepted(pitem->gpg_id) || pitem->gpg_id == AuthGPG::getAuthGPG()->getGPGOwnId())
// Check if already friend.
if(AuthGPG::getAuthGPG()->isGPGAccepted(pit->gpg_id) || pit->gpg_id == AuthGPG::getAuthGPG()->getGPGOwnId())
{
if (!mPeerMgr->isFriend(pit->pid))
{ {
// Add with no disc by default. If friend already exists, it will do nothing // Add with no disc by default. If friend already exists, it will do nothing
// // NO DISC is important - otherwise, we'll just enter a nasty loop,
#ifdef P3DISC_DEBUG // where every addition triggers requests, then they are cleaned up, and readded...
std::cerr << "--> Adding to friends list " << pitem->pid << " - " << pitem->gpg_id << std::endl;
#endif
mPeerMgr->addFriend(pitem->pid, pitem->gpg_id, pitem->netMode, 0, 0);
RsPeerDetails storedDetails;
// Update if know this peer // This way we get their addresses, but don't advertise them until we get a
if(rsPeers->getPeerDetails(pitem->pid, storedDetails)) // connection.
{
// Update if it's fresh info or if it's from the peer itself
// their info is fresher than ours, update ours
//
if(!(storedDetails.state & RS_PEER_CONNECTED))
{
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "Friend is not connected -> updating info" << std::endl; std::cerr << "--> Adding to friends list " << pit->pid << " - " << pit->gpg_id << std::endl;
std::cerr << " -> network mode: " << pitem->netMode << std::endl;
std::cerr << " -> location: " << pitem->location << std::endl;
#endif #endif
mPeerMgr->setNetworkMode(pitem->pid, pitem->netMode); mPeerMgr->addFriend(pit->pid, pit->gpg_id, pit->netMode, RS_VIS_STATE_NODISC, 0);
}
} }
mPeerMgr->setLocation(pitem->pid, pitem->location);
// The info from the peer itself is ultimately trustable, so we can override some info, /* skip if not one of our peers */
// such as: if (!mPeerMgr->isFriend(pit->pid))
// - local and global addresses {
// - address list continue;
// }
// If we enter here, we're necessarily connected to this peer.
// if (item->PeerId() == pit->pid)
if (item->PeerId() == pitem->pid)
{ {
std::cerr << "Info sent by the peer itself -> updating self info:" << std::endl;
std::cerr << " -> current local addr = " << pitem->currentlocaladdr << std::endl;
std::cerr << " -> current remote addr = " << pitem->currentremoteaddr << std::endl;
//std::cerr << " -> clearing NODISC flag " << std::endl;
std::cerr << " -> visState = " << std::hex << pitem->visState << std::dec;
std::cerr << std::endl;
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "Info sent by the peer itself -> updating self info:" << std::endl;
std::cerr << " -> current local addr = " << pit->currentlocaladdr << std::endl;
std::cerr << " -> current remote addr = " << pit->currentremoteaddr << std::endl;
std::cerr << " -> visState = " << std::hex << pit->visState << std::dec;
std::cerr << " -> network mode: " << pit->netMode << std::endl;
std::cerr << " -> location: " << pit->location << std::endl;
std::cerr << std::endl;
#endif #endif
// When the peer sends his own list of IPs, the info replaces the existing info, because the // When the peer sends his own list of IPs, the info replaces the existing info, because the
// peer is the primary source of his own IPs. // peer is the primary source of his own IPs.
mPeerMgr->setNetworkMode(pit->pid, pit->netMode);
mPeerMgr->setLocation(pit->pid, pit->location);
mPeerMgr->setLocalAddress(pit->pid, pit->currentlocaladdr);
mPeerMgr->setExtAddress(pit->pid, pit->currentremoteaddr);
mPeerMgr->setVisState(pit->pid, pit->visState);
mPeerMgr->setLocalAddress(pitem->pid, pitem->currentlocaladdr); if (pit->dyndns != "")
mPeerMgr->setExtAddress(pitem->pid, pitem->currentremoteaddr); mPeerMgr->setDynDNS(pit->pid, pit->dyndns);
//pitem->visState &= ~RS_VIS_STATE_NODISC ;
mPeerMgr->setVisState(pitem->pid, pitem->visState);
}
}
else
{
std::cerr << "p3disc:: ERROR HOW DID WE GET HERE?" << std::endl;
} }
// always update historical address list... this should be enough to let us connect.
pqiIpAddrSet addrsFromPeer; pqiIpAddrSet addrsFromPeer;
addrsFromPeer.mLocal.extractFromTlv(pitem->localAddrList); addrsFromPeer.mLocal.extractFromTlv(pit->localAddrList);
addrsFromPeer.mExt.extractFromTlv(pitem->extAddrList); addrsFromPeer.mExt.extractFromTlv(pit->extAddrList);
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "Setting address list to peer " << pitem->pid << ", to be:" << std::endl ; std::cerr << "Setting address list to peer " << pit->pid << ", to be:" << std::endl ;
addrsFromPeer.printAddrs(std::cerr); addrsFromPeer.printAddrs(std::cerr);
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
// allways update address list and dns, except if it's ours mPeerMgr->updateAddressList(pit->pid, addrsFromPeer);
if (pitem->dyndns != "")
mPeerMgr->setDynDNS(pitem->pid, pitem->dyndns);
mPeerMgr->updateAddressList(pitem->pid, addrsFromPeer);
} }
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
else else
{ {
std::cerr << " skipping unknown gpg id " << pitem->gpg_id << std::endl ; std::cerr << "Skipping info about own id " << pit->pid << std::endl ;
}
#endif
}
#ifdef P3DISC_DEBUG
else
{
std::cerr << "Skipping info about own id " << pitem->pid << std::endl ;
} }
#endif #endif
@ -765,21 +795,60 @@ void p3disc::recvHeartbeatMsg(RsDiscHeartbeat *item)
return; return;
} }
void p3disc::recvAskInfo(RsDiscAskInfo *item) { void p3disc::recvAskInfo(RsDiscAskInfo *item)
{
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::recvAskInfo() From: " << item->PeerId(); std::cerr << "p3disc::recvAskInfo() From: " << item->PeerId();
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/ RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
std::list<std::string> &idList = sendIdList[item->PeerId()]; /* only provide info if discovery is on */
if (!mDiscEnabled)
{
#ifdef P3DISC_DEBUG
std::cerr << "p3disc::recvAskInfo() Disc Disabled => NULL OP";
std::cerr << std::endl;
#endif
return;
}
std::list<std::string> &idList = mSendIdList[item->PeerId()];
if (std::find(idList.begin(), idList.end(), item->gpg_id) == idList.end()) { if (std::find(idList.begin(), idList.end(), item->gpg_id) == idList.end()) {
idList.push_back(item->gpg_id); idList.push_back(item->gpg_id);
} }
} }
void p3disc::removeFriend(std::string ssl_id) { void p3disc::recvDiscReply(RsDiscReply *dri)
{
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
/* search pending item and remove it, when already exist */
std::list<RsDiscReply*>::iterator it;
for (it = mPendingDiscReplyInList.begin(); it != mPendingDiscReplyInList.end(); it++)
{
if ((*it)->PeerId() == dri->PeerId() && (*it)->aboutId == dri->aboutId)
{
delete (*it);
mPendingDiscReplyInList.erase(it);
break;
}
}
// add item to list for later process
mPendingDiscReplyInList.push_back(dri); // no delete
}
void p3disc::removeFriend(std::string ssl_id)
{
// DON'T KNOW WHY SSL IDS were saved -> the results are never used
#if 0
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::removeFriend() called for : " << ssl_id << std::endl; std::cerr << "p3disc::removeFriend() called for : " << ssl_id << std::endl;
#endif #endif
@ -795,6 +864,9 @@ void p3disc::removeFriend(std::string ssl_id) {
deletedSSLFriendsIds[ssl_id] = time(NULL);//just keep track of the deleted time deletedSSLFriendsIds[ssl_id] = time(NULL);//just keep track of the deleted time
IndicateConfigChanged(); IndicateConfigChanged();
} }
#endif
} }
/*************************************************************************************/ /*************************************************************************************/
@ -806,8 +878,8 @@ AuthGPGOperation *p3disc::getGPGOperation()
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/ RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
/* process disc reply in list */ /* process disc reply in list */
if (pendingDiscReplyInList.empty() == false) { if (mPendingDiscReplyInList.empty() == false) {
RsDiscReply *item = pendingDiscReplyInList.front(); RsDiscReply *item = mPendingDiscReplyInList.front();
return new AuthGPGOperationLoadOrSave(true, item->certGPG, item); return new AuthGPGOperationLoadOrSave(true, item->certGPG, item);
} }
@ -821,20 +893,21 @@ AuthGPGOperation *p3disc::getGPGOperation()
{ {
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/ RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
while (!sendIdList.empty()) { while (!mSendIdList.empty())
std::map<std::string, std::list<std::string> >::iterator sendIdIt = sendIdList.begin(); {
std::map<std::string, std::list<std::string> >::iterator it = mSendIdList.begin();
if (!sendIdIt->second.empty() && mLinkMgr->isOnline(sendIdIt->first)) { if (!it->second.empty() && mLinkMgr->isOnline(it->first)) {
std::string gpgId = sendIdIt->second.front(); std::string gpgId = it->second.front();
sendIdIt->second.pop_front(); it->second.pop_front();
destId = sendIdIt->first; destId = it->first;
srcId = gpgId; srcId = gpgId;
break; break;
} else { } else {
/* peer is not online anymore ... try next */ /* peer is not online anymore ... try next */
sendIdList.erase(sendIdIt); mSendIdList.erase(it);
} }
} }
} }
@ -860,10 +933,11 @@ void p3disc::setGPGOperation(AuthGPGOperation *operation)
{ {
RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/ RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/
std::list<RsDiscReply*>::iterator it = std::find(pendingDiscReplyInList.begin(), pendingDiscReplyInList.end(), loadOrSave->m_userdata); std::list<RsDiscReply*>::iterator it;
if (it != pendingDiscReplyInList.end()) { it = std::find(mPendingDiscReplyInList.begin(), mPendingDiscReplyInList.end(), loadOrSave->m_userdata);
if (it != mPendingDiscReplyInList.end()) {
item = *it; item = *it;
pendingDiscReplyInList.erase(it); mPendingDiscReplyInList.erase(it);
} }
} }
@ -1002,6 +1076,8 @@ bool p3disc::potentialproxies(const std::string& id, std::list<std::string> &pro
} }
return true; return true;
} }
bool p3disc::potentialGPGproxies(const std::string& gpg_id, std::list<std::string> &proxyGPGIds) bool p3disc::potentialGPGproxies(const std::string& gpg_id, std::list<std::string> &proxyGPGIds)
{ {
/* find id -> and extract the neighbour_of ids */ /* find id -> and extract the neighbour_of ids */
@ -1040,13 +1116,13 @@ void p3disc::getWaitingDiscCount(unsigned int *sendCount, unsigned int *recvCoun
*sendCount = 0; *sendCount = 0;
std::map<std::string, std::list<std::string> >::iterator it; std::map<std::string, std::list<std::string> >::iterator it;
for (it = sendIdList.begin(); it != sendIdList.end(); it++) { for (it = mSendIdList.begin(); it != mSendIdList.end(); it++) {
*sendCount += it->second.size(); *sendCount += it->second.size();
} }
} }
if (recvCount) { if (recvCount) {
*recvCount = pendingDiscReplyInList.size(); *recvCount = mPendingDiscReplyInList.size();
} }
} }
@ -1160,11 +1236,13 @@ bool p3disc::saveList(bool& cleanup, std::list<RsItem*>& lst)
#endif #endif
cleanup = true ; cleanup = true ;
// DON'T KNOW WHY SSL IDS were saved -> the results are never used
#if 0
// Now save config for network digging strategies // Now save config for network digging strategies
RsConfigKeyValueSet *vitem = new RsConfigKeyValueSet ; RsConfigKeyValueSet *vitem = new RsConfigKeyValueSet ;
std::map<std::string, time_t>::iterator mapIt; std::map<std::string, time_t>::iterator mapIt;
for (mapIt = deletedSSLFriendsIds.begin(); mapIt != deletedSSLFriendsIds.end(); mapIt++) { for (mapIt = deletedSSLFriendsIds.begin(); mapIt != deletedSSLFriendsIds.end(); mapIt++)
{
RsTlvKeyValue kv; RsTlvKeyValue kv;
kv.key = mapIt->first; kv.key = mapIt->first;
std::ostringstream time_string; std::ostringstream time_string;
@ -1176,6 +1254,7 @@ bool p3disc::saveList(bool& cleanup, std::list<RsItem*>& lst)
#endif #endif
} }
lst.push_back(vitem); lst.push_back(vitem);
#endif
return true ; return true ;
} }
@ -1186,14 +1265,19 @@ bool p3disc::loadList(std::list<RsItem*>& load)
std::cerr << "p3disc::loadList() Item Count: " << load.size() << std::endl; std::cerr << "p3disc::loadList() Item Count: " << load.size() << std::endl;
#endif #endif
RsStackMutex stack(mDiscMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mDiscMtx); /****** STACK LOCK MUTEX *******/
/* load the list of accepted gpg keys */ /* load the list of accepted gpg keys */
std::list<RsItem *>::iterator it; std::list<RsItem *>::iterator it;
for(it = load.begin(); it != load.end(); it++) { for(it = load.begin(); it != load.end(); it++)
{
RsConfigKeyValueSet *vitem = dynamic_cast<RsConfigKeyValueSet *>(*it); RsConfigKeyValueSet *vitem = dynamic_cast<RsConfigKeyValueSet *>(*it);
if(vitem) { // DON'T KNOW WHY SSL IDS were saved -> the results are never used
#if 0
if(vitem)
{
#ifdef P3DISC_DEBUG #ifdef P3DISC_DEBUG
std::cerr << "p3disc::loadList() General Variable Config Item:" << std::endl; std::cerr << "p3disc::loadList() General Variable Config Item:" << std::endl;
vitem->print(std::cerr, 10); vitem->print(std::cerr, 10);
@ -1201,13 +1285,16 @@ bool p3disc::loadList(std::list<RsItem*>& load)
#endif #endif
std::list<RsTlvKeyValue>::iterator kit; std::list<RsTlvKeyValue>::iterator kit;
for(kit = vitem->tlvkvs.pairs.begin(); kit != vitem->tlvkvs.pairs.end(); kit++) { for(kit = vitem->tlvkvs.pairs.begin(); kit != vitem->tlvkvs.pairs.end(); kit++)
{
std::istringstream instream(kit->value); std::istringstream instream(kit->value);
time_t deleted_time_t; time_t deleted_time_t;
instream >> deleted_time_t; instream >> deleted_time_t;
deletedSSLFriendsIds[kit->key] = deleted_time_t; deletedSSLFriendsIds[kit->key] = deleted_time_t;
} }
} }
#endif
delete (*it); delete (*it);
} }
return true; return true;

20
libretroshare/src/services/p3disc.h
View File

@ -129,6 +129,7 @@ void recvPeerDetails(RsDiscReply *item, const std::string &certGpgId);
//void recvPeerIssuerMsg(RsDiscIssuer *item); //void recvPeerIssuerMsg(RsDiscIssuer *item);
void recvPeerVersionMsg(RsDiscVersion *item); void recvPeerVersionMsg(RsDiscVersion *item);
void recvHeartbeatMsg(RsDiscHeartbeat *item); void recvHeartbeatMsg(RsDiscHeartbeat *item);
void recvDiscReply(RsDiscReply *dri);
void removeFriend(std::string ssl_id); //keep tracks of removed friend so we're not gonna add them again immediately void removeFriend(std::string ssl_id); //keep tracks of removed friend so we're not gonna add them again immediately
@ -146,22 +147,27 @@ int idServers();
p3LinkMgr *mLinkMgr; p3LinkMgr *mLinkMgr;
pqipersongrp *mPqiPersonGrp; pqipersongrp *mPqiPersonGrp;
time_t lastSentHeartbeatTime;
/* data */ /* data */
RsMutex mDiscMtx; RsMutex mDiscMtx;
std::map<std::string, time_t> deletedSSLFriendsIds; time_t mLastSentHeartbeatTime;
bool mDiscEnabled;
std::map<std::string, autoneighbour> neighbours; //std::map<std::string, time_t> deletedSSLFriendsIds;
std::map<std::string, std::string> versions;
std::map<std::string, std::list<std::string> > sendIdList;
std::list<RsDiscReply*> pendingDiscReplyInList; std::map<std::string, std::list<std::string> > mSendIdList;
std::list<RsDiscReply*> mPendingDiscReplyInList;
// Neighbors at the gpg level. // Neighbors at the gpg level.
//
std::map<std::string,std::set<std::string> > gpg_neighbors ; std::map<std::string,std::set<std::string> > gpg_neighbors ;
// Original mapping.
std::map<std::string, autoneighbour> neighbours;
// Rs Version.
std::map<std::string, std::string> versions;
}; };

1
libretroshare/src/services/p3distrib.cc
View File

@ -49,6 +49,7 @@
#include "pqi/authssl.h" #include "pqi/authssl.h"
#include "pqi/authgpg.h" #include "pqi/authgpg.h"
#include "retroshare/rspeers.h" // Needed for RsPeerDetails & Online List. (Should remove dependance)
#define FAILED_CACHE_CONT "failedcachegrp" // cache id which have failed are stored under a node of this name/grpid #define FAILED_CACHE_CONT "failedcachegrp" // cache id which have failed are stored under a node of this name/grpid
#define HIST_CACHE_FNAME "grp_history.xml" #define HIST_CACHE_FNAME "grp_history.xml"

6
libretroshare/src/services/p3tunnel.cc
View File

@ -24,9 +24,9 @@
*/ */
#include "retroshare/rsiface.h" //#include "retroshare/rsiface.h"
#include "retroshare/rsinit.h" /* for PGPSSL flag */ //#include "retroshare/rsinit.h" /* for PGPSSL flag */
#include "retroshare/rspeers.h" //#include "retroshare/rspeers.h"
#include "services/p3tunnel.h" #include "services/p3tunnel.h"
#include "pqi/pqissltunnel.h" #include "pqi/pqissltunnel.h"
#include <sstream> #include <sstream>

13
libretroshare/src/turtle/p3turtle.cc
View File

@ -33,8 +33,6 @@
#endif #endif
#include "retroshare/rsiface.h" #include "retroshare/rsiface.h"
#include "retroshare/rspeers.h"
#include "retroshare/rsfiles.h"
#include "pqi/authssl.h" #include "pqi/authssl.h"
#include "pqi/p3linkmgr.h" #include "pqi/p3linkmgr.h"
@ -2153,15 +2151,14 @@ void p3turtle::getInfo( std::vector<std::vector<std::string> >& hashes_info,
tunnel.push_back(printNumber(it->first,true)) ; tunnel.push_back(printNumber(it->first,true)) ;
RsPeerDetails sslDetails; std::string name;
if(mLinkMgr->getPeerName(it->second.local_src,name))
if(rsPeers->getPeerDetails(it->second.local_src,sslDetails)) tunnel.push_back(name) ;
tunnel.push_back(sslDetails.name + " - " + sslDetails.location) ;
else else
tunnel.push_back(it->second.local_src) ; tunnel.push_back(it->second.local_src) ;
if(rsPeers->getPeerDetails(it->second.local_dst,sslDetails)) if(mLinkMgr->getPeerName(it->second.local_dst,name))
tunnel.push_back(sslDetails.name + " - " + sslDetails.location) ; tunnel.push_back(name) ;
else else
tunnel.push_back(it->second.local_dst); tunnel.push_back(it->second.local_dst);