Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-08-15 09:36:23 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

id cleaning - continued

Browse source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.6-IdCleaning@7092 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
csoler 2014-02-04 22:51:19 +00:00
parent 33ab4ee3b5
commit c4c8414a79
23 changed files with 380 additions and 389 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -81,7 +81,7 @@ virtual int dhtInfoCallback(const bdId *id, uint32_t type, uint32_t flags, std::
}; };
p3BitDht::p3BitDht(std::string id, pqiConnectCb *cb, p3NetMgr *nm, p3BitDht::p3BitDht(const RsPeerId& id, pqiConnectCb *cb, p3NetMgr *nm,
UdpStack *udpstack, std::string bootstrapfile) UdpStack *udpstack, std::string bootstrapfile)
:p3Config(CONFIG_TYPE_BITDHT), pqiNetAssistConnect(id, cb), mNetMgr(nm), dhtMtx("p3BitDht") :p3Config(CONFIG_TYPE_BITDHT), pqiNetAssistConnect(id, cb), mNetMgr(nm), dhtMtx("p3BitDht")
{ {

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

@ -52,7 +52,7 @@ class DhtPeerDetails
uint32_t mPeerType; uint32_t mPeerType;
bdId mDhtId; bdId mDhtId;
std::string mRsId; RsPeerId mRsId;
/* direct from the DHT! */ /* direct from the DHT! */
uint32_t mDhtState; // One of RSDHT_PEERDHT_[...] uint32_t mDhtState; // One of RSDHT_PEERDHT_[...]
@ -142,7 +142,7 @@ class p3NetMgr;
class p3BitDht: public p3Config, public pqiNetAssistConnect, public RsDht class p3BitDht: public p3Config, public pqiNetAssistConnect, public RsDht
{ {
public: public:
p3BitDht(std::string id, pqiConnectCb *cb, p3NetMgr *nm, p3BitDht(const RsPeerId& id, pqiConnectCb *cb, p3NetMgr *nm,
UdpStack *udpstack, std::string bootstrapfile); UdpStack *udpstack, std::string bootstrapfile);
@ -155,8 +155,8 @@ virtual ~p3BitDht();
virtual uint32_t getNetState(uint32_t type); virtual uint32_t getNetState(uint32_t type);
virtual int getDhtPeers(int lvl, std::list<RsDhtPeer> &peers); virtual int getDhtPeers(int lvl, std::list<RsDhtPeer> &peers);
virtual int getNetPeerList(std::list<std::string> &peerIds); virtual int getNetPeerList(std::list<RsPeerId> &peerIds);
virtual int getNetPeerStatus(std::string peerId, RsDhtNetPeer &status); virtual int getNetPeerStatus(const RsPeerId& peerId, RsDhtNetPeer &status);
virtual int getRelayEnds(std::list<RsDhtRelayEnd> &relayEnds); virtual int getRelayEnds(std::list<RsDhtRelayEnd> &relayEnds);
virtual int getRelayProxies(std::list<RsDhtRelayProxy> &relayProxies); virtual int getRelayProxies(std::list<RsDhtRelayProxy> &relayProxies);
@ -194,20 +194,20 @@ virtual bool getNetworkStats(uint32_t &netsize, uint32_t &localnetsize);
/* pqiNetAssistConnect - external interface functions */ /* pqiNetAssistConnect - external interface functions */
/* add / remove peers */ /* add / remove peers */
virtual bool findPeer(std::string id); virtual bool findPeer(const RsPeerId& id);
virtual bool dropPeer(std::string id); virtual bool dropPeer(const RsPeerId& id);
virtual int addBadPeer(const struct sockaddr_storage &addr, uint32_t reason, uint32_t flags, uint32_t age); virtual int addBadPeer(const struct sockaddr_storage &addr, uint32_t reason, uint32_t flags, uint32_t age);
virtual int addKnownPeer(const std::string &pid, const struct sockaddr_storage &addr, uint32_t flags); virtual int addKnownPeer(const RsPeerId &pid, const struct sockaddr_storage &addr, uint32_t flags);
//virtual int addFriend(const std::string pid); //virtual int addFriend(const std::string pid);
//virtual int addFriendOfFriend(const std::string pid); //virtual int addFriendOfFriend(const std::string pid);
//virtual int addOther(const std::string pid); //virtual int addOther(const std::string pid);
/* feedback on success failure of Connections */ /* feedback on success failure of Connections */
virtual void ConnectionFeedback(std::string pid, int state); virtual void ConnectionFeedback(const RsPeerId& pid, int state);
/* extract current peer status */ /* extract current peer status */
virtual bool getPeerStatus(std::string id, virtual bool getPeerStatus(const RsPeerId& id,
struct sockaddr_storage &laddr, struct sockaddr_storage &raddr, struct sockaddr_storage &laddr, struct sockaddr_storage &raddr,
uint32_t &type, uint32_t &mode); uint32_t &type, uint32_t &mode);
@ -255,18 +255,18 @@ int installRelayConnection(const bdId *srcId, const bdId *destId, uint32_t &ban
int removeRelayConnection(const bdId *srcId, const bdId *destId); int removeRelayConnection(const bdId *srcId, const bdId *destId);
void monitorConnections(); void monitorConnections();
void ConnectCallout(const std::string &peerId, struct sockaddr_in addr, uint32_t connectMode); void ConnectCallout(const RsPeerId &peerId, struct sockaddr_in addr, uint32_t connectMode);
void ConnectCalloutTCPAttempt(const std::string &peerId, struct sockaddr_in addr); void ConnectCalloutTCPAttempt(const RsPeerId &peerId, struct sockaddr_in addr);
void ConnectCalloutDirectOrProxy(const std::string &peerId, struct sockaddr_in raddr, uint32_t connectFlags, uint32_t delay); void ConnectCalloutDirectOrProxy(const RsPeerId &peerId, struct sockaddr_in raddr, uint32_t connectFlags, uint32_t delay);
void ConnectCalloutRelay(const std::string &peerId, struct sockaddr_in srcaddr, void ConnectCalloutRelay(const RsPeerId &peerId, struct sockaddr_in srcaddr,
struct sockaddr_in proxyaddr, struct sockaddr_in destaddr, struct sockaddr_in proxyaddr, struct sockaddr_in destaddr,
uint32_t connectMode, uint32_t bandwidth); uint32_t connectMode, uint32_t bandwidth);
void Feedback_Connected(std::string pid); void Feedback_Connected(const RsPeerId& pid);
void Feedback_ConnectionFailed(std::string pid); void Feedback_ConnectionFailed(const RsPeerId& pid);
void Feedback_ConnectionClosed(std::string pid); void Feedback_ConnectionClosed(const RsPeerId& pid);
void UdpConnectionFailed_locked(DhtPeerDetails *dpd); void UdpConnectionFailed_locked(DhtPeerDetails *dpd);
void ReleaseProxyExclusiveMode_locked(DhtPeerDetails *dpd, bool addrChgLikely); void ReleaseProxyExclusiveMode_locked(DhtPeerDetails *dpd, bool addrChgLikely);
@ -337,24 +337,24 @@ int pushRelayServers();
public: public:
int removePeer(const std::string pid); int removePeer(const RsPeerId& pid);
// Can be used externally too. // Can be used externally too.
int calculateNodeId(const std::string pid, bdNodeId *id); int calculateNodeId(const RsPeerId& pid, bdNodeId *id);
int addKnownNode(const bdId *id, uint32_t flags); int addKnownNode(const bdId *id, uint32_t flags);
private: private:
DhtPeerDetails *addInternalPeer_locked(const std::string pid, uint32_t type); DhtPeerDetails *addInternalPeer_locked(const RsPeerId& pid, uint32_t type);
int removeInternalPeer_locked(const std::string pid); int removeInternalPeer_locked(const RsPeerId& pid);
DhtPeerDetails *findInternalDhtPeer_locked(const bdNodeId *id, uint32_t type); DhtPeerDetails *findInternalDhtPeer_locked(const bdNodeId *id, uint32_t type);
DhtPeerDetails *findInternalRsPeer_locked(const std::string &pid); DhtPeerDetails *findInternalRsPeer_locked(const RsPeerId &pid);
bool havePeerTranslation_locked(const std::string &pid); bool havePeerTranslation_locked(const RsPeerId &pid);
int lookupNodeId_locked(const std::string pid, bdNodeId *id); int lookupNodeId_locked(const RsPeerId& pid, bdNodeId *id);
int lookupRsId_locked(const bdNodeId *id, std::string &pid); int lookupRsId_locked(const bdNodeId *id, RsPeerId &pid);
int storeTranslation_locked(const std::string pid); int storeTranslation_locked(const RsPeerId& pid);
int removeTranslation_locked(const std::string pid); int removeTranslation_locked(const RsPeerId& pid);
UdpBitDht *mUdpBitDht; /* has own mutex, is static except for creation/destruction */ UdpBitDht *mUdpBitDht; /* has own mutex, is static except for creation/destruction */
UdpStunner *mDhtStunner; UdpStunner *mDhtStunner;
@ -372,14 +372,14 @@ int removeTranslation_locked(const std::string pid);
p3BitDhtRelayHandler *mRelayHandler; p3BitDhtRelayHandler *mRelayHandler;
std::string mOwnRsId; RsPeerId mOwnRsId;
bdNodeId mOwnDhtId; bdNodeId mOwnDhtId;
time_t mMinuteTS; time_t mMinuteTS;
/* translation maps */ /* translation maps */
std::map<std::string, bdNodeId> mTransToNodeId; std::map<RsPeerId, bdNodeId> mTransToNodeId;
std::map<bdNodeId, std::string> mTransToRsId; std::map<bdNodeId, RsPeerId> mTransToRsId;
std::map<bdNodeId, DhtPeerDetails> mPeers; std::map<bdNodeId, DhtPeerDetails> mPeers;
std::map<bdNodeId, DhtPeerDetails> mFailedPeers; std::map<bdNodeId, DhtPeerDetails> mFailedPeers;

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

@ -48,7 +48,7 @@
int p3BitDht::InfoCallback(const bdId *id, uint32_t /*type*/, uint32_t /*flags*/, std::string /*info*/) int p3BitDht::InfoCallback(const bdId *id, uint32_t /*type*/, uint32_t /*flags*/, std::string /*info*/)
{ {
/* translate info */ /* translate info */
std::string rsid; RsPeerId rsid;
struct sockaddr_in addr = id->addr; struct sockaddr_in addr = id->addr;
int outtype = PNASS_TYPE_BADPEER; int outtype = PNASS_TYPE_BADPEER;
int outreason = PNASS_REASON_UNKNOWN; int outreason = PNASS_REASON_UNKNOWN;
@ -632,7 +632,7 @@ int p3BitDht::ConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId
/* if we get here, we are an endpoint (peer specified in peerId) */ /* if we get here, we are an endpoint (peer specified in peerId) */
/* translate id into string for exclusive mode */ /* translate id into string for exclusive mode */
std::string pid; RsPeerId pid;
bdStdPrintNodeId(pid, &(peerId.id), false); bdStdPrintNodeId(pid, &(peerId.id), false);
switch(cbtype) switch(cbtype)
@ -1178,7 +1178,7 @@ int p3BitDht::doActions()
bool grabbedExclusivePort = false; bool grabbedExclusivePort = false;
/* translate id into string for exclusive mode */ /* translate id into string for exclusive mode */
std::string pid; RsPeerId pid;
bdStdPrintNodeId(pid, &(action.mDestId.id), false); bdStdPrintNodeId(pid, &(action.mDestId.id), false);
@ -1569,7 +1569,7 @@ int p3BitDht::doActions()
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
std::string peerRsId; RsPeerId peerRsId;
bool foundPeerId = false; bool foundPeerId = false;
{ {
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/ RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
@ -1774,7 +1774,7 @@ int p3BitDht::checkConnectionAllowed(const bdId *peerId, int mode)
*/ */
void p3BitDht::ConnectCalloutTCPAttempt(const std::string &peerId, struct sockaddr_in raddrv4) void p3BitDht::ConnectCalloutTCPAttempt(const RsPeerId &peerId, struct sockaddr_in raddrv4)
{ {
struct sockaddr_storage raddr; struct sockaddr_storage raddr;
struct sockaddr_storage proxyaddr; struct sockaddr_storage proxyaddr;
@ -1802,7 +1802,7 @@ void p3BitDht::ConnectCalloutTCPAttempt(const std::string &peerId, struct sockad
} }
void p3BitDht::ConnectCalloutDirectOrProxy(const std::string &peerId, struct sockaddr_in raddrv4, uint32_t connectFlags, uint32_t delay) void p3BitDht::ConnectCalloutDirectOrProxy(const RsPeerId &peerId, struct sockaddr_in raddrv4, uint32_t connectFlags, uint32_t delay)
{ {
struct sockaddr_storage raddr; struct sockaddr_storage raddr;
struct sockaddr_storage proxyaddr; struct sockaddr_storage proxyaddr;
@ -1827,7 +1827,7 @@ void p3BitDht::ConnectCalloutDirectOrProxy(const std::string &peerId, struct soc
mConnCb->peerConnectRequest(peerId, raddr, proxyaddr, srcaddr, source, connectFlags, delay, bandwidth); mConnCb->peerConnectRequest(peerId, raddr, proxyaddr, srcaddr, source, connectFlags, delay, bandwidth);
} }
void p3BitDht::ConnectCalloutRelay(const std::string &peerId, void p3BitDht::ConnectCalloutRelay(const RsPeerId &peerId,
struct sockaddr_in srcaddrv4, struct sockaddr_in proxyaddrv4, struct sockaddr_in destaddrv4, struct sockaddr_in srcaddrv4, struct sockaddr_in proxyaddrv4, struct sockaddr_in destaddrv4,
uint32_t connectFlags, uint32_t bandwidth) uint32_t connectFlags, uint32_t bandwidth)
{ {
@ -1944,7 +1944,7 @@ void p3BitDht::initiateConnection(const bdId *srcId, const bdId *proxyId, const
#endif #endif
// uint32_t touConnectMode = 0; // uint32_t touConnectMode = 0;
std::string rsId; RsPeerId rsId;
{ {
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/ RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
@ -2054,10 +2054,10 @@ int p3BitDht::installRelayConnection(const bdId *srcId, const bdId *destId, uint
int relayClass = UDP_RELAY_CLASS_GENERAL; int relayClass = UDP_RELAY_CLASS_GENERAL;
#ifdef DEBUG_PEERNET #ifdef DEBUG_PEERNET
std::string strId1; RsPeerId strId1;
bdStdPrintNodeId(strId1, &(srcId->id), false); bdStdPrintNodeId(strId1, &(srcId->id), false);
std::string strId2; RsPeerId strId2;
bdStdPrintNodeId(strId2, &(destId->id), false); bdStdPrintNodeId(strId2, &(destId->id), false);
#endif #endif
@ -2180,7 +2180,7 @@ void p3BitDht::monitorConnections()
void p3BitDht::Feedback_Connected(std::string pid) void p3BitDht::Feedback_Connected(const RsPeerId& pid)
{ {
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/ RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalRsPeer_locked(pid); DhtPeerDetails *dpd = findInternalRsPeer_locked(pid);
@ -2255,7 +2255,7 @@ void p3BitDht::Feedback_Connected(std::string pid)
ReleaseProxyExclusiveMode_locked(dpd, true); ReleaseProxyExclusiveMode_locked(dpd, true);
} }
void p3BitDht::Feedback_ConnectionFailed(std::string pid) void p3BitDht::Feedback_ConnectionFailed(const RsPeerId& pid)
{ {
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/ RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalRsPeer_locked(pid); DhtPeerDetails *dpd = findInternalRsPeer_locked(pid);
@ -2278,7 +2278,7 @@ void p3BitDht::Feedback_ConnectionFailed(std::string pid)
return UdpConnectionFailed_locked(dpd); return UdpConnectionFailed_locked(dpd);
} }
void p3BitDht::Feedback_ConnectionClosed(std::string pid) void p3BitDht::Feedback_ConnectionClosed(const RsPeerId& pid)
{ {
RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/ RsStackMutex stack(dhtMtx); /********** LOCKED MUTEX ***************/
DhtPeerDetails *dpd = findInternalRsPeer_locked(pid); DhtPeerDetails *dpd = findInternalRsPeer_locked(pid);
@ -2382,7 +2382,7 @@ void p3BitDht::ReleaseProxyExclusiveMode_locked(DhtPeerDetails *dpd, bool addrCh
std::cerr << std::endl; std::cerr << std::endl;
/* translate id into string for exclusive mode */ /* translate id into string for exclusive mode */
std::string pid; RsPeerId pid;
bdStdPrintNodeId(pid, &(dpd->mDhtId.id), false); bdStdPrintNodeId(pid, &(dpd->mDhtId.id), false);
@ -2419,7 +2419,7 @@ void p3BitDht::ReleaseProxyExclusiveMode_locked(DhtPeerDetails *dpd, bool addrCh
} }
void p3BitDht::ConnectionFeedback(std::string pid, int mode) void p3BitDht::ConnectionFeedback(const RsPeerId& pid, int mode)
{ {
#ifdef DEBUG_PEERNET #ifdef DEBUG_PEERNET
std::cerr << "p3BitDht::ConnectionFeedback() peer: " << pid; std::cerr << "p3BitDht::ConnectionFeedback() peer: " << pid;

2
libretroshare/src/ft/ftcontroller.cc
View file

@ -2138,7 +2138,7 @@ bool ftController::saveList(bool &cleanup, std::list<RsItem *>& saveData)
// Remove turtle peers from sources, as they are not supposed to survive a reboot of RS, since they are dynamic sources. // Remove turtle peers from sources, as they are not supposed to survive a reboot of RS, since they are dynamic sources.
// Otherwize, such sources are unknown from the turtle router, at restart, and never get removed. // Otherwize, such sources are unknown from the turtle router, at restart, and never get removed.
// //
for(std::list<std::string>::iterator sit(rft->allPeerIds.ids.begin());sit!=rft->allPeerIds.ids.end();) for(std::list<RsPeerId>::iterator sit(rft->allPeerIds.ids.begin());sit!=rft->allPeerIds.ids.end();)
if(mTurtle->isTurtlePeer(*sit)) if(mTurtle->isTurtlePeer(*sit))
{ {
std::list<std::string>::iterator sittmp(sit) ; std::list<std::string>::iterator sittmp(sit) ;

166
libretroshare/src/pqi/authgpg.cc
View file

@ -61,11 +61,11 @@ bool AuthGPG::decryptTextFromFile(std::string& text,const std::string& inputfile
return PGPHandler::decryptTextFromFile(mOwnGpgId,text,inputfile) ; return PGPHandler::decryptTextFromFile(mOwnGpgId,text,inputfile) ;
} }
bool AuthGPG::removeKeysFromPGPKeyring(const std::list<std::string>& pgp_ids,std::string& backup_file,uint32_t& error_code) bool AuthGPG::removeKeysFromPGPKeyring(const std::list<PGPIdType>& pgp_ids,std::string& backup_file,uint32_t& error_code)
{ {
std::list<PGPIdType> pids ; std::list<PGPIdType> pids ;
for(std::list<std::string>::const_iterator it(pgp_ids.begin());it!=pgp_ids.end();++it) for(std::list<PGPIdType>::const_iterator it(pgp_ids.begin());it!=pgp_ids.end();++it)
pids.push_back(PGPIdType(*it)) ; pids.push_back(PGPIdType(*it)) ;
return PGPHandler::removeKeysFromPGPKeyring(pids,backup_file,error_code) ; return PGPHandler::removeKeysFromPGPKeyring(pids,backup_file,error_code) ;
@ -317,22 +317,14 @@ bool AuthGPG::VerifySignature(const void *data, int datalen, const void *sig, un
return PGPHandler::VerifySignBin((unsigned char*)data,datalen,(unsigned char*)sig,siglen,withfingerprint) ; return PGPHandler::VerifySignBin((unsigned char*)data,datalen,(unsigned char*)sig,siglen,withfingerprint) ;
} }
bool AuthGPG::exportProfile(const std::string& fname,const std::string& exported_id) bool AuthGPG::exportProfile(const std::string& fname,const PGPIdType& exported_id)
{ {
return PGPHandler::exportGPGKeyPair(fname,PGPIdType(exported_id)) ; return PGPHandler::exportGPGKeyPair(fname,exported_id) ;
} }
bool AuthGPG::importProfile(const std::string& fname,std::string& imported_id,std::string& import_error) bool AuthGPG::importProfile(const std::string& fname,PGPIdType& imported_id,std::string& import_error)
{ {
PGPIdType id ; return PGPHandler::importGPGKeyPair(fname,imported_id,import_error) ;
if(PGPHandler::importGPGKeyPair(fname,id,import_error))
{
imported_id = id.toStdString() ;
return true ;
}
else
return false ;
} }
@ -343,35 +335,19 @@ bool AuthGPG::active()
return gpgKeySelected; return gpgKeySelected;
} }
bool AuthGPG::GeneratePGPCertificate(const std::string& name, bool AuthGPG::GeneratePGPCertificate(const std::string& name, const std::string& email, const std::string& passwd, PGPIdType& pgpId, std::string& errString)
const std::string& email, const std::string& passwd, std::string &pgpId, std::string& errString)
{ {
RsStackMutex stack(gpgMtxEngine); /******* LOCKED ******/ RsStackMutex stack(gpgMtxEngine); /******* LOCKED ******/
PGPIdType id ; return PGPHandler::GeneratePGPCertificate(name, email, passwd, pgpId, errString) ;
bool res = PGPHandler::GeneratePGPCertificate(name, email, passwd, id, errString) ;
pgpId = id.toStdString() ;
return res ;
} }
/**** These Two are common */ /**** These Two are common */
std::string AuthGPG::getGPGName(const std::string &id,bool *success) std::string AuthGPG::getGPGName(const PGPIdType& id,bool *success)
{ {
if(id.length() != 16)
{
static int already = 0 ;
if(already < 10)
{
std::cerr << "Wrong string passed to getGPGDetails: \"" << id << "\"" << std::endl;
already++ ;
}
return std::string() ;
}
RsStackMutex stack(gpgMtxData); /******* LOCKED ******/ RsStackMutex stack(gpgMtxData); /******* LOCKED ******/
const PGPCertificateInfo *info = getCertInfoFromStdString(id) ; const PGPCertificateInfo *info = getCertificateInfo(id) ;
if(info != NULL) if(info != NULL)
{ {
@ -386,10 +362,10 @@ std::string AuthGPG::getGPGName(const std::string &id,bool *success)
} }
/**** These Two are common */ /**** These Two are common */
std::string AuthGPG::getGPGEmail(const std::string &id,bool *success) std::string AuthGPG::getGPGEmail(const PGPIdType& id,bool *success)
{ {
RsStackMutex stack(gpgMtxData); /******* LOCKED ******/ RsStackMutex stack(gpgMtxData); /******* LOCKED ******/
const PGPCertificateInfo *info = getCertInfoFromStdString(id) ; const PGPCertificateInfo *info = getCertificateInfo(id) ;
if(info != NULL) if(info != NULL)
{ {
@ -413,18 +389,14 @@ PGPIdType AuthGPG::getGPGOwnId()
std::string AuthGPG::getGPGOwnName() std::string AuthGPG::getGPGOwnName()
{ {
return getGPGName(mOwnGpgId.toStdString()) ; return getGPGName(mOwnGpgId) ;
} }
bool AuthGPG::getGPGAllList(std::list<std::string> &ids) bool AuthGPG::getGPGAllList(std::list<PGPIdType> &ids)
{ {
RsStackMutex stack(gpgMtxData); /******* LOCKED ******/ RsStackMutex stack(gpgMtxData); /******* LOCKED ******/
std::list<PGPIdType> list ; PGPHandler::getGPGFilteredList(ids) ;
PGPHandler::getGPGFilteredList(list) ;
for(std::list<PGPIdType>::const_iterator it(list.begin());it!=list.end();++it)
ids.push_back( (*it).toStdString() ) ;
return true; return true;
} }
@ -440,13 +412,13 @@ const PGPCertificateInfo *AuthGPG::getCertInfoFromStdString(const std::string& p
return NULL ; return NULL ;
} }
} }
bool AuthGPG::haveSecretKey(const std::string& id) const //bool AuthGPG::haveSecretKey(const PGPIdType& id) const
//{
// return PGPHandler::haveSecretKey(PGPIdType(id)) ;
//}
bool AuthGPG::isKeySupported(const PGPIdType& id) const
{ {
return PGPHandler::haveSecretKey(PGPIdType(id)) ; const PGPCertificateInfo *pc = getCertificateInfo(id) ;
}
bool AuthGPG::isKeySupported(const std::string& id) const
{
const PGPCertificateInfo *pc = getCertInfoFromStdString(id) ;
if(pc == NULL) if(pc == NULL)
return false ; return false ;
@ -485,39 +457,39 @@ bool AuthGPG::getGPGDetails(const PGPIdType& pgp_id, RsPeerDetails &d)
return true; return true;
} }
bool AuthGPG::getGPGFilteredList(std::list<std::string>& list,bool (*filter)(const PGPCertificateInfo&)) //bool AuthGPG::getGPGFilteredList(std::list<PGPIdType>& list,bool (*filter)(const PGPCertificateInfo&))
{ //{
RsStackMutex stack(gpgMtxData); /******* LOCKED ******/ // RsStackMutex stack(gpgMtxData); /******* LOCKED ******/
std::list<PGPIdType> ids ; // std::list<PGPIdType> ids ;
//
PGPHandler::getGPGFilteredList(ids,filter) ; // PGPHandler::getGPGFilteredList(ids,filter) ;
//
for(std::list<PGPIdType>::const_iterator it(ids.begin());it!=ids.end();++it) // for(std::list<PGPIdType>::const_iterator it(ids.begin());it!=ids.end();++it)
list.push_back( (*it).toStdString() ) ; // list.push_back( (*it).toStdString() ) ;
//
return true ; // return true ;
} //}
static bool filter_Validity(const PGPCertificateInfo& /*info*/) { return true ; } //{ return info._validLvl >= PGPCertificateInfo::GPGME_VALIDITY_MARGINAL ; } static bool filter_Validity(const PGPCertificateInfo& /*info*/) { return true ; } //{ return info._validLvl >= PGPCertificateInfo::GPGME_VALIDITY_MARGINAL ; }
static bool filter_Accepted(const PGPCertificateInfo& info) { return info._flags & PGPCertificateInfo::PGP_CERTIFICATE_FLAG_ACCEPT_CONNEXION ; } static bool filter_Accepted(const PGPCertificateInfo& info) { return info._flags & PGPCertificateInfo::PGP_CERTIFICATE_FLAG_ACCEPT_CONNEXION ; }
static bool filter_OwnSigned(const PGPCertificateInfo& info) { return info._flags & PGPCertificateInfo::PGP_CERTIFICATE_FLAG_HAS_OWN_SIGNATURE ; } static bool filter_OwnSigned(const PGPCertificateInfo& info) { return info._flags & PGPCertificateInfo::PGP_CERTIFICATE_FLAG_HAS_OWN_SIGNATURE ; }
bool AuthGPG::getGPGValidList(std::list<std::string> &ids) bool AuthGPG::getGPGValidList(std::list<PGPIdType> &ids)
{ {
return getGPGFilteredList(ids,&filter_Validity); return getGPGFilteredList(ids,&filter_Validity);
} }
bool AuthGPG::getGPGAcceptedList(std::list<std::string> &ids) bool AuthGPG::getGPGAcceptedList(std::list<PGPIdType> &ids)
{ {
return getGPGFilteredList(ids,&filter_Accepted); return getGPGFilteredList(ids,&filter_Accepted);
} }
bool AuthGPG::getGPGSignedList(std::list<std::string> &ids) bool AuthGPG::getGPGSignedList(std::list<PGPIdType> &ids)
{ {
return getGPGFilteredList(ids,&filter_OwnSigned); return getGPGFilteredList(ids,&filter_OwnSigned);
} }
bool AuthGPG::getCachedGPGCertificate(const std::string &id, std::string &certificate) bool AuthGPG::getCachedGPGCertificate(const PGPIdType &id, std::string &certificate)
{ {
RsStackMutex stack(gpgMtxData); /******* LOCKED ******/ RsStackMutex stack(gpgMtxData); /******* LOCKED ******/
#ifdef LIMIT_CERTIFICATE_SIZE #ifdef LIMIT_CERTIFICATE_SIZE
@ -545,28 +517,28 @@ bool AuthGPG::getCachedGPGCertificate(const std::string &id, std::string &certif
/* SKTAN : do not know how to use std::string id */ /* SKTAN : do not know how to use std::string id */
std::string AuthGPG::SaveCertificateToString(const std::string &id,bool include_signatures) // std::string AuthGPG::SaveCertificateToString(const PGPIdType &id,bool include_signatures)
{ // {
if (!isGPGId(id)) {
std::cerr << "AuthGPG::SaveCertificateToString() unknown ID" << std::endl;
return "";
}
RsStackMutex stack(gpgMtxEngine); /******* LOCKED ******/
std::string tmp = PGPHandler::SaveCertificateToString(PGPIdType(id),include_signatures) ;
// // Try to remove signatures manually.
// //
// std::string cleaned_key ;
// //
// if( (!include_signatures) && PGPKeyManagement::createMinimalKey(tmp,cleaned_key)) // if (!isGPGId(id)) {
// return cleaned_key ; // std::cerr << "AuthGPG::SaveCertificateToString() unknown ID" << std::endl;
// else // return "";
// }
return tmp; //
} // RsStackMutex stack(gpgMtxEngine); /******* LOCKED ******/
//
// std::string tmp = PGPHandler::SaveCertificateToString(PGPIdType(id),include_signatures) ;
//
// // // Try to remove signatures manually.
// // //
// // std::string cleaned_key ;
// //
// // if( (!include_signatures) && PGPKeyManagement::createMinimalKey(tmp,cleaned_key))
// // return cleaned_key ;
// // else
//
// return tmp;
// }
/* import to GnuPG and other Certificates */ /* import to GnuPG and other Certificates */
bool AuthGPG::LoadCertificateFromString(const std::string &str, PGPIdType& gpg_id,std::string& error_string) bool AuthGPG::LoadCertificateFromString(const std::string &str, PGPIdType& gpg_id,std::string& error_string)
@ -596,7 +568,7 @@ bool AuthGPG::LoadCertificateFromString(const std::string &str, PGPIdType& gpg_i
/*************************************/ /*************************************/
/* These take PGP Ids */ /* These take PGP Ids */
bool AuthGPG::AllowConnection(const std::string &gpg_id, bool accept) bool AuthGPG::AllowConnection(const PGPIdType& gpg_id, bool accept)
{ {
#ifdef GPG_DEBUG #ifdef GPG_DEBUG
std::cerr << "AuthGPG::AllowConnection(" << gpg_id << ")" << std::endl; std::cerr << "AuthGPG::AllowConnection(" << gpg_id << ")" << std::endl;
@ -605,7 +577,7 @@ bool AuthGPG::AllowConnection(const std::string &gpg_id, bool accept)
/* Was a "Reload Certificates" here -> be shouldn't be needed -> and very expensive, try without. */ /* Was a "Reload Certificates" here -> be shouldn't be needed -> and very expensive, try without. */
{ {
RsStackMutex stack(gpgMtxData); RsStackMutex stack(gpgMtxData);
PGPHandler::setAcceptConnexion(PGPIdType(gpg_id),accept) ; PGPHandler::setAcceptConnexion(gpg_id,accept) ;
} }
IndicateConfigChanged(); IndicateConfigChanged();
@ -616,7 +588,7 @@ bool AuthGPG::AllowConnection(const std::string &gpg_id, bool accept)
} }
/* These take PGP Ids */ /* These take PGP Ids */
bool AuthGPG::SignCertificateLevel0(const std::string &id) bool AuthGPG::SignCertificateLevel0(const PGPIdType &id)
{ {
#ifdef GPG_DEBUG #ifdef GPG_DEBUG
std::cerr << "AuthGPG::SignCertificat(" << id << ")" << std::endl; std::cerr << "AuthGPG::SignCertificat(" << id << ")" << std::endl;
@ -625,7 +597,7 @@ bool AuthGPG::SignCertificateLevel0(const std::string &id)
return privateSignCertificate(id) ; return privateSignCertificate(id) ;
} }
bool AuthGPG::RevokeCertificate(const std::string &id) bool AuthGPG::RevokeCertificate(const PGPIdType &id)
{ {
/* remove unused parameter warnings */ /* remove unused parameter warnings */
(void) id; (void) id;
@ -645,10 +617,10 @@ bool AuthGPG::TrustCertificate(const PGPIdType& id, int trustlvl)
return privateTrustCertificate(id, trustlvl) ; return privateTrustCertificate(id, trustlvl) ;
} }
bool AuthGPG::encryptDataBin(const std::string& pgp_id,const void *data, unsigned int datalen, unsigned char *sign, unsigned int *signlen) //bool AuthGPG::encryptDataBin(const PGPIdType& pgp_id,const void *data, unsigned int datalen, unsigned char *sign, unsigned int *signlen)
{ //{
return PGPHandler::encryptDataBin(PGPIdType(pgp_id),data,datalen,sign,signlen) ; // return PGPHandler::encryptDataBin(PGPIdType(pgp_id),data,datalen,sign,signlen) ;
} //}
bool AuthGPG::decryptDataBin(const void *data, unsigned int datalen, unsigned char *sign, unsigned int *signlen) bool AuthGPG::decryptDataBin(const void *data, unsigned int datalen, unsigned char *sign, unsigned int *signlen)
{ {
@ -666,11 +638,11 @@ bool AuthGPG::VerifySignBin(const void *data, uint32_t datalen, unsigned char *s
/* Sign/Trust stuff */ /* Sign/Trust stuff */
int AuthGPG::privateSignCertificate(const std::string &id) int AuthGPG::privateSignCertificate(const PGPIdType &id)
{ {
RsStackMutex stack(gpgMtxData); /******* LOCKED ******/ RsStackMutex stack(gpgMtxData); /******* LOCKED ******/
int ret = PGPHandler::privateSignCertificate(mOwnGpgId,PGPIdType(id)) ; int ret = PGPHandler::privateSignCertificate(mOwnGpgId,id) ;
_force_sync_database = true ; _force_sync_database = true ;
return ret ; return ret ;
} }
@ -694,7 +666,7 @@ int AuthGPG::privateTrustCertificate(const PGPIdType& id, int trustlvl)
return 0; return 0;
} }
int res = PGPHandler::privateTrustCertificate(PGPIdType(id),trustlvl) ; int res = PGPHandler::privateTrustCertificate(id,trustlvl) ;
_force_sync_database = true ; _force_sync_database = true ;
return res ; return res ;
} }

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

@ -120,7 +120,7 @@ peerConnectState::peerConnectState()
std::string textPeerConnectState(peerConnectState &state) std::string textPeerConnectState(peerConnectState &state)
{ {
return "Id: " + state.id + "\n"; return "Id: " + state.id.toStdString() + "\n";
} }
/********* /*********
@ -182,11 +182,11 @@ bool p3LinkMgrIMPL::getLocalAddress(struct sockaddr_storage &addr)
} }
bool p3LinkMgrIMPL::isOnline(const std::string &ssl_id) bool p3LinkMgrIMPL::isOnline(const RsPeerId &ssl_id)
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(ssl_id); it = mFriendList.find(ssl_id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -202,11 +202,11 @@ bool p3LinkMgrIMPL::isOnline(const std::string &ssl_id)
uint32_t p3LinkMgrIMPL::getLinkType(const std::string &ssl_id) uint32_t p3LinkMgrIMPL::getLinkType(const RsPeerId &ssl_id)
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(ssl_id); it = mFriendList.find(ssl_id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -222,11 +222,11 @@ uint32_t p3LinkMgrIMPL::getLinkType(const std::string &ssl_id)
void p3LinkMgrIMPL::getOnlineList(std::list<std::string> &ssl_peers) void p3LinkMgrIMPL::getOnlineList(std::list<RsPeerId> &ssl_peers)
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
if (it->second.state & RS_PEER_S_CONNECTED) if (it->second.state & RS_PEER_S_CONNECTED)
@ -237,11 +237,11 @@ void p3LinkMgrIMPL::getOnlineList(std::list<std::string> &ssl_peers)
return; return;
} }
void p3LinkMgrIMPL::getFriendList(std::list<std::string> &ssl_peers) void p3LinkMgrIMPL::getFriendList(std::list<RsPeerId> &ssl_peers)
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
ssl_peers.push_back(it->first); ssl_peers.push_back(it->first);
@ -249,17 +249,17 @@ void p3LinkMgrIMPL::getFriendList(std::list<std::string> &ssl_peers)
return; return;
} }
bool p3LinkMgrIMPL::getPeerName(const std::string &ssl_id, std::string &name) bool p3LinkMgrIMPL::getPeerName(const RsPeerId &ssl_id, std::string &name)
{ {
return mPeerMgr->getPeerName(ssl_id, name); return mPeerMgr->getPeerName(ssl_id, name);
} }
bool p3LinkMgrIMPL::getFriendNetStatus(const std::string &id, peerConnectState &state) bool p3LinkMgrIMPL::getFriendNetStatus(const RsPeerId &id, peerConnectState &state)
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(id); it = mFriendList.find(id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -273,13 +273,13 @@ bool p3LinkMgrIMPL::getFriendNetStatus(const std::string &id, peerConnectStat
void p3LinkMgrIMPL::setFriendVisibility(const std::string &id, bool isVisible) void p3LinkMgrIMPL::setFriendVisibility(const RsPeerId &id, bool isVisible)
{ {
/* set visibility */ /* set visibility */
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(id); it = mFriendList.find(id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -327,8 +327,8 @@ void p3LinkMgrIMPL::statusTick()
#ifdef LINKMGR_DEBUG_TICK #ifdef LINKMGR_DEBUG_TICK
std::cerr << "p3LinkMgrIMPL::statusTick()" << std::endl; std::cerr << "p3LinkMgrIMPL::statusTick()" << std::endl;
#endif #endif
std::list<std::string> retryIds; std::list<RsPeerId> retryIds;
std::list<std::string>::iterator it2; std::list<RsPeerId>::iterator it2;
//std::list<std::string> dummyToRemove; //std::list<std::string> dummyToRemove;
{ {
@ -337,7 +337,7 @@ void p3LinkMgrIMPL::statusTick()
time_t retry = now - mRetryPeriod; time_t retry = now - mRetryPeriod;
RsStackMutex stack(mLinkMtx); /****** LOCK MUTEX ******/ RsStackMutex stack(mLinkMtx); /****** LOCK MUTEX ******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
if (it->second.state & RS_PEER_S_CONNECTED) if (it->second.state & RS_PEER_S_CONNECTED)
@ -421,7 +421,7 @@ void p3LinkMgrIMPL::tickMonitors()
{ {
bool doStatusChange = false; bool doStatusChange = false;
std::list<pqipeer> actionList; std::list<pqipeer> actionList;
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
@ -449,7 +449,7 @@ void p3LinkMgrIMPL::tickMonitors()
actionList.push_back(peer); actionList.push_back(peer);
#ifdef LINKMGR_DEBUG_ACTIONS #ifdef LINKMGR_DEBUG_ACTIONS
std::cerr << "Friend: " << peer.name << " Id: " << peer.id << " State: " << peer.state; std::cerr << "Friend: " << peer.name << " Id: " << peer.id.toStdString() << " State: " << peer.state;
if (peer.state & RS_PEER_S_FRIEND) if (peer.state & RS_PEER_S_FRIEND)
std::cerr << " S:RS_PEER_S_FRIEND"; std::cerr << " S:RS_PEER_S_FRIEND";
if (peer.state & RS_PEER_S_ONLINE) if (peer.state & RS_PEER_S_ONLINE)
@ -500,7 +500,7 @@ void p3LinkMgrIMPL::tickMonitors()
it->second.actions = 0; it->second.actions = 0;
#ifdef LINKMGR_DEBUG_ACTIONS #ifdef LINKMGR_DEBUG_ACTIONS
std::cerr << "Other: " << peer.name << " Id: " << peer.id << " State: " << peer.state; std::cerr << "Other: " << peer.name << " Id: " << peer.id.toStdString() << " State: " << peer.state;
if (peer.state & RS_PEER_S_FRIEND) if (peer.state & RS_PEER_S_FRIEND)
std::cerr << " S:RS_PEER_S_FRIEND"; std::cerr << " S:RS_PEER_S_FRIEND";
if (peer.state & RS_PEER_S_ONLINE) if (peer.state & RS_PEER_S_ONLINE)
@ -576,13 +576,13 @@ void p3LinkMgrIMPL::tickMonitors()
} }
const std::string p3LinkMgrIMPL::getOwnId() const RsPeerId p3LinkMgrIMPL::getOwnId()
{ {
return AuthSSL::getAuthSSL()->OwnId(); return AuthSSL::getAuthSSL()->OwnId();
} }
bool p3LinkMgrIMPL::connectAttempt(const std::string &id, struct sockaddr_storage &raddr, bool p3LinkMgrIMPL::connectAttempt(const RsPeerId &id, struct sockaddr_storage &raddr,
struct sockaddr_storage &proxyaddr, struct sockaddr_storage &proxyaddr,
struct sockaddr_storage &srcaddr, struct sockaddr_storage &srcaddr,
uint32_t &delay, uint32_t &period, uint32_t &type, uint32_t &flags, uint32_t &bandwidth, uint32_t &delay, uint32_t &period, uint32_t &type, uint32_t &flags, uint32_t &bandwidth,
@ -592,7 +592,7 @@ bool p3LinkMgrIMPL::connectAttempt(const std::string &id, struct sockaddr_storag
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(id); it = mFriendList.find(id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -774,7 +774,7 @@ bool p3LinkMgrIMPL::connectAttempt(const std::string &id, struct sockaddr_storag
* *
*/ */
bool p3LinkMgrIMPL::connectResult(const std::string &id, bool success, uint32_t flags, const struct sockaddr_storage &remote_peer_address) bool p3LinkMgrIMPL::connectResult(const RsPeerId &id, bool success, uint32_t flags, const struct sockaddr_storage &remote_peer_address)
{ {
bool doDhtAssist = false ; bool doDhtAssist = false ;
bool updatePeerAddr = false; bool updatePeerAddr = false;
@ -791,7 +791,7 @@ bool p3LinkMgrIMPL::connectResult(const std::string &id, bool success, uint32_t
return false; return false;
} }
/* check for existing */ /* check for existing */
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(id); it = mFriendList.find(id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -806,7 +806,7 @@ bool p3LinkMgrIMPL::connectResult(const std::string &id, bool success, uint32_t
/* now we can tell if we think we were connected - proper point to log */ /* now we can tell if we think we were connected - proper point to log */
{ {
std::string out = "p3LinkMgrIMPL::connectResult() id: " + id; std::string out = "p3LinkMgrIMPL::connectResult() id: " + id.toStdString();
if (success) if (success)
{ {
out += " SUCCESS "; out += " SUCCESS ";
@ -1030,7 +1030,7 @@ bool p3LinkMgrIMPL::connectResult(const std::string &id, bool success, uint32_t
*/ */
// from pqissl, when a connection failed due to security // from pqissl, when a connection failed due to security
void p3LinkMgrIMPL::notifyDeniedConnection(const std::string& gpgid,const std::string& sslid,const std::string& sslcn,const struct sockaddr_storage &addr, bool incoming) void p3LinkMgrIMPL::notifyDeniedConnection(const PGPIdType& gpgid,const RsPeerId& sslid,const std::string& sslcn,const struct sockaddr_storage &addr, bool incoming)
{ {
std::cerr << "p3LinkMgrIMPL::notifyDeniedConnection()"; std::cerr << "p3LinkMgrIMPL::notifyDeniedConnection()";
std::cerr << " pgpid: " << gpgid; std::cerr << " pgpid: " << gpgid;
@ -1040,7 +1040,7 @@ void p3LinkMgrIMPL::notifyDeniedConnection(const std::string& gpgid,const std::
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(sslid); it = mFriendList.find(sslid);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -1070,12 +1070,12 @@ void p3LinkMgrIMPL::notifyDeniedConnection(const std::string& gpgid,const std::
} }
void p3LinkMgrIMPL::peerStatus(std::string id, const pqiIpAddrSet &addrs, void p3LinkMgrIMPL::peerStatus(const RsPeerId& id, const pqiIpAddrSet &addrs,
uint32_t type, uint32_t flags, uint32_t source) uint32_t type, uint32_t flags, uint32_t source)
{ {
/* HACKED UP FIX ****/ /* HACKED UP FIX ****/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
bool isFriend = true; bool isFriend = true;
time_t now = time(NULL); time_t now = time(NULL);
@ -1344,7 +1344,7 @@ void p3LinkMgrIMPL::peerStatus(std::string id, const pqiIpAddrSet &addrs,
} }
/* This has become very unwieldy - as extra arguments are required for UDP connections */ /* This has become very unwieldy - as extra arguments are required for UDP connections */
void p3LinkMgrIMPL::peerConnectRequest(std::string id, const struct sockaddr_storage &raddr, const struct sockaddr_storage &proxyaddr, const struct sockaddr_storage &srcaddr, void p3LinkMgrIMPL::peerConnectRequest(const RsPeerId& id, const struct sockaddr_storage &raddr, const struct sockaddr_storage &proxyaddr, const struct sockaddr_storage &srcaddr,
uint32_t source, uint32_t flags, uint32_t delay, uint32_t bandwidth) uint32_t source, uint32_t flags, uint32_t delay, uint32_t bandwidth)
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
@ -1397,7 +1397,7 @@ void p3LinkMgrIMPL::peerConnectRequest(std::string id, const struct sockaddr_
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
@ -1449,7 +1449,7 @@ void p3LinkMgrIMPL::peerConnectRequest(std::string id, const struct sockaddr_
/*******************************************************************/ /*******************************************************************/
/*******************************************************************/ /*******************************************************************/
/*************** External Control ****************/ /*************** External Control ****************/
bool p3LinkMgrIMPL::retryConnect(const std::string &id) bool p3LinkMgrIMPL::retryConnect(const RsPeerId &id)
{ {
/* push all available addresses onto the connect addr stack */ /* push all available addresses onto the connect addr stack */
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
@ -1467,7 +1467,7 @@ bool p3LinkMgrIMPL::retryConnect(const std::string &id)
bool p3LinkMgrIMPL::tryConnectUDP(const std::string &id, const struct sockaddr_storage &rUdpAddr, bool p3LinkMgrIMPL::tryConnectUDP(const RsPeerId &id, const struct sockaddr_storage &rUdpAddr,
const struct sockaddr_storage &proxyaddr, const struct sockaddr_storage &srcaddr, const struct sockaddr_storage &proxyaddr, const struct sockaddr_storage &srcaddr,
uint32_t flags, uint32_t delay, uint32_t bandwidth) uint32_t flags, uint32_t delay, uint32_t bandwidth)
@ -1514,7 +1514,7 @@ bool p3LinkMgrIMPL::tryConnectUDP(const std::string &id, const struct sockaddr
} }
/* look up the id */ /* look up the id */
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
@ -1564,7 +1564,7 @@ bool p3LinkMgrIMPL::tryConnectUDP(const std::string &id, const struct sockaddr
bool p3LinkMgrIMPL::retryConnectTCP(const std::string &id) bool p3LinkMgrIMPL::retryConnectTCP(const RsPeerId &id)
{ {
/* Check if we should retry first */ /* Check if we should retry first */
{ {
@ -1589,7 +1589,7 @@ bool p3LinkMgrIMPL::retryConnectTCP(const std::string &id)
} }
/* look up the id */ /* look up the id */
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
@ -1626,7 +1626,7 @@ bool p3LinkMgrIMPL::retryConnectTCP(const std::string &id)
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
if (mFriendList.end() != (it = mFriendList.find(id))) if (mFriendList.end() != (it = mFriendList.find(id)))
{ {
locked_ConnectAttempt_ProxyAddress(&(it->second), proxy_addr, domain_addr, domain_port); locked_ConnectAttempt_ProxyAddress(&(it->second), proxy_addr, domain_addr, domain_port);
@ -1652,7 +1652,7 @@ bool p3LinkMgrIMPL::retryConnectTCP(const std::string &id)
{ {
RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mLinkMtx); /****** STACK LOCK MUTEX *******/
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
if (mFriendList.end() != (it = mFriendList.find(id))) if (mFriendList.end() != (it = mFriendList.find(id)))
{ {
locked_ConnectAttempt_CurrentAddresses(&(it->second), lAddr, eAddr); locked_ConnectAttempt_CurrentAddresses(&(it->second), lAddr, eAddr);
@ -2125,7 +2125,7 @@ bool p3LinkMgrIMPL::locked_ConnectAttempt_Complete(peerConnectState *peer)
************************************* Handling of Friends ************************************************* ************************************* Handling of Friends *************************************************
***********************************************************************************************************/ ***********************************************************************************************************/
int p3LinkMgrIMPL::addFriend(const std::string &id, bool isVisible) int p3LinkMgrIMPL::addFriend(const RsPeerId &id, bool isVisible)
{ {
rslog(RSL_WARNING, p3connectzone, "p3LinkMgr::addFriend() id: " + id); rslog(RSL_WARNING, p3connectzone, "p3LinkMgr::addFriend() id: " + id);
@ -2137,7 +2137,7 @@ int p3LinkMgrIMPL::addFriend(const std::string &id, bool isVisible)
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(id); it = mFriendList.find(id);
if (it != mFriendList.end()) if (it != mFriendList.end())
@ -2166,7 +2166,7 @@ int p3LinkMgrIMPL::addFriend(const std::string &id, bool isVisible)
} }
int p3LinkMgrIMPL::removeFriend(const std::string &id) int p3LinkMgrIMPL::removeFriend(const RsPeerId &id)
{ {
rslog(RSL_WARNING, p3connectzone, "p3LinkMgr::removeFriend() id: " + id); rslog(RSL_WARNING, p3connectzone, "p3LinkMgr::removeFriend() id: " + id);
@ -2178,7 +2178,7 @@ int p3LinkMgrIMPL::removeFriend(const std::string &id)
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
it = mFriendList.find(id); it = mFriendList.find(id);
if (it == mFriendList.end()) if (it == mFriendList.end())
@ -2218,10 +2218,10 @@ void p3LinkMgrIMPL::printPeerLists(std::ostream &out)
out << std::endl; out << std::endl;
std::map<std::string, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
out << "\t SSL ID: " << it->second.id; out << "\t SSL ID: " << it->second.id.toStdString();
out << "\t State: " << it->second.state; out << "\t State: " << it->second.state;
out << std::endl; out << std::endl;
} }
@ -2230,7 +2230,7 @@ void p3LinkMgrIMPL::printPeerLists(std::ostream &out)
out << std::endl; out << std::endl;
for(it = mOthersList.begin(); it != mOthersList.end(); it++) for(it = mOthersList.begin(); it != mOthersList.end(); it++)
{ {
out << "\t SSL ID: " << it->second.id; out << "\t SSL ID: " << it->second.id.toStdString();
out << "\t State: " << it->second.state; out << "\t State: " << it->second.state;
} }
} }
@ -2242,7 +2242,7 @@ void p3LinkMgrIMPL::printPeerLists(std::ostream &out)
void printConnectState(std::ostream &out, peerConnectState &peer) void printConnectState(std::ostream &out, peerConnectState &peer)
{ {
out << "Friend: " << peer.name << " Id: " << peer.id << " State: " << peer.state; out << "Friend: " << peer.name << " Id: " << peer.id.toStdString() << " State: " << peer.state;
if (peer.state & RS_PEER_S_FRIEND) if (peer.state & RS_PEER_S_FRIEND)
out << " S:RS_PEER_S_FRIEND"; out << " S:RS_PEER_S_FRIEND";
if (peer.state & RS_PEER_S_ONLINE) if (peer.state & RS_PEER_S_ONLINE)

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

@ -896,7 +896,7 @@ void p3NetMgrIMPL::netExtCheck()
} }
/* inform DHT about our external address */ /* inform DHT about our external address */
std::string fakeId; RsPeerId fakeId;
netAssistKnownPeer(fakeId, mExtAddr, NETASSIST_KNOWN_PEER_SELF | NETASSIST_KNOWN_PEER_ONLINE); netAssistKnownPeer(fakeId, mExtAddr, NETASSIST_KNOWN_PEER_SELF | NETASSIST_KNOWN_PEER_ONLINE);
rslog(RSL_WARNING, p3netmgrzone, "p3NetMgr::netExtCheck() Network Setup Complete"); rslog(RSL_WARNING, p3netmgrzone, "p3NetMgr::netExtCheck() Network Setup Complete");
@ -1378,7 +1378,7 @@ bool p3NetMgrIMPL::netAssistConnectShutdown()
return true; return true;
} }
bool p3NetMgrIMPL::netAssistFriend(const std::string &id, bool on) bool p3NetMgrIMPL::netAssistFriend(const RsPeerId &id, bool on)
{ {
std::map<uint32_t, pqiNetAssistConnect *>::iterator it; std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
@ -1398,7 +1398,7 @@ bool p3NetMgrIMPL::netAssistFriend(const std::string &id, bool on)
} }
bool p3NetMgrIMPL::netAssistKnownPeer(const std::string &id, const struct sockaddr_storage &addr, uint32_t flags) bool p3NetMgrIMPL::netAssistKnownPeer(const RsPeerId &id, const struct sockaddr_storage &addr, uint32_t flags)
{ {
std::map<uint32_t, pqiNetAssistConnect *>::iterator it; std::map<uint32_t, pqiNetAssistConnect *>::iterator it;
@ -1449,7 +1449,7 @@ bool p3NetMgrIMPL::netAssistAttach(bool on)
bool p3NetMgrIMPL::netAssistStatusUpdate(const std::string &id, int state) bool p3NetMgrIMPL::netAssistStatusUpdate(const RsPeerId &id, int state)
{ {
std::map<uint32_t, pqiNetAssistConnect *>::iterator it; std::map<uint32_t, pqiNetAssistConnect *>::iterator it;

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

@ -118,10 +118,10 @@ virtual bool setNetworkMode(uint32_t netMode) = 0;
virtual bool setVisState(uint16_t vs_disc, uint16_t vs_dht) = 0; virtual bool setVisState(uint16_t vs_disc, uint16_t vs_dht) = 0;
// Switch DHT On/Off. // Switch DHT On/Off.
virtual bool netAssistFriend(const std::string &id, bool on) = 0; virtual bool netAssistFriend(const RsPeerId &id, bool on) = 0;
virtual bool netAssistKnownPeer(const std::string &id, const struct sockaddr_storage &addr, uint32_t flags) = 0; virtual bool netAssistKnownPeer(const RsPeerId &id, const struct sockaddr_storage &addr, uint32_t flags) = 0;
virtual bool netAssistBadPeer(const struct sockaddr_storage &addr, uint32_t reason, uint32_t flags, uint32_t age) = 0; virtual bool netAssistBadPeer(const struct sockaddr_storage &addr, uint32_t reason, uint32_t flags, uint32_t age) = 0;
virtual bool netAssistStatusUpdate(const std::string &id, int mode) = 0; virtual bool netAssistStatusUpdate(const RsPeerId &id, int mode) = 0;
/* Get Network State */ /* Get Network State */
virtual uint32_t getNetStateMode() = 0; virtual uint32_t getNetStateMode() = 0;
@ -174,10 +174,10 @@ virtual bool setNetworkMode(uint32_t netMode);
virtual bool setVisState(uint16_t vs_disc, uint16_t vs_dht); virtual bool setVisState(uint16_t vs_disc, uint16_t vs_dht);
// Switch DHT On/Off. // Switch DHT On/Off.
virtual bool netAssistFriend(const std::string &id, bool on); virtual bool netAssistFriend(const RsPeerId &id, bool on);
virtual bool netAssistKnownPeer(const std::string &id, const struct sockaddr_storage &addr, uint32_t flags); virtual bool netAssistKnownPeer(const RsPeerId &id, const struct sockaddr_storage &addr, uint32_t flags);
virtual bool netAssistBadPeer(const struct sockaddr_storage &addr, uint32_t reason, uint32_t flags, uint32_t age); virtual bool netAssistBadPeer(const struct sockaddr_storage &addr, uint32_t reason, uint32_t flags, uint32_t age);
virtual bool netAssistStatusUpdate(const std::string &id, int mode); virtual bool netAssistStatusUpdate(const RsPeerId &id, int mode);
/* Get Network State */ /* Get Network State */
virtual uint32_t getNetStateMode(); virtual uint32_t getNetStateMode();

185
libretroshare/src/pqi/p3peermgr.cc
View file

@ -110,7 +110,7 @@ std::string textPeerConnectState(peerState &state)
} }
p3PeerMgrIMPL::p3PeerMgrIMPL(const SSLIdType& ssl_own_id, const PGPIdType& gpg_own_id, const PGPIdType& gpg_own_name, const RsPeerId& ssl_own_location) p3PeerMgrIMPL::p3PeerMgrIMPL(const RsPeerId& ssl_own_id, const PGPIdType& gpg_own_id, const PGPIdType& gpg_own_name, const RsPeerId& ssl_own_location)
:p3Config(CONFIG_TYPE_PEERS), mPeerMtx("p3PeerMgr"), mStatusChanged(false) :p3Config(CONFIG_TYPE_PEERS), mPeerMtx("p3PeerMgr"), mStatusChanged(false)
{ {
@ -294,7 +294,7 @@ void p3PeerMgrIMPL::tick()
*/ */
const SSLIdType& p3PeerMgrIMPL::getOwnId() const RsPeerId& p3PeerMgrIMPL::getOwnId()
{ {
return AuthSSL::getAuthSSL()->OwnId(); return AuthSSL::getAuthSSL()->OwnId();
} }
@ -307,7 +307,7 @@ bool p3PeerMgrIMPL::getOwnNetStatus(peerState &state)
return true; return true;
} }
bool p3PeerMgrIMPL::isFriend(const SSLIdType& id) bool p3PeerMgrIMPL::isFriend(const RsPeerId& id)
{ {
#ifdef PEER_DEBUG_COMMON #ifdef PEER_DEBUG_COMMON
std::cerr << "p3PeerMgrIMPL::isFriend(" << id << ") called" << std::endl; std::cerr << "p3PeerMgrIMPL::isFriend(" << id << ") called" << std::endl;
@ -320,12 +320,12 @@ bool p3PeerMgrIMPL::isFriend(const SSLIdType& id)
return ret; return ret;
} }
bool p3PeerMgrIMPL::getPeerName(const SSLIdType &ssl_id, std::string &name) bool p3PeerMgrIMPL::getPeerName(const RsPeerId &ssl_id, std::string &name)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
it = mFriendList.find(ssl_id); it = mFriendList.find(ssl_id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -336,12 +336,12 @@ bool p3PeerMgrIMPL::getPeerName(const SSLIdType &ssl_id, std::string &name)
return true; return true;
} }
bool p3PeerMgrIMPL::getGpgId(const SSLIdType &ssl_id, PGPIdType &gpgId) bool p3PeerMgrIMPL::getGpgId(const RsPeerId &ssl_id, PGPIdType &gpgId)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
it = mFriendList.find(ssl_id); it = mFriendList.find(ssl_id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -361,12 +361,12 @@ bool p3PeerMgrIMPL::isHidden()
} }
bool p3PeerMgrIMPL::isHiddenPeer(const SSLIdType &ssl_id) bool p3PeerMgrIMPL::isHiddenPeer(const RsPeerId &ssl_id)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
it = mFriendList.find(ssl_id); it = mFriendList.find(ssl_id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -381,7 +381,7 @@ bool p3PeerMgrIMPL::isHiddenPeer(const SSLIdType &ssl_id)
return (it->second).hiddenNode; return (it->second).hiddenNode;
} }
bool p3PeerMgrIMPL::setHiddenDomainPort(const SSLIdType &ssl_id, const std::string &domain_addr, const uint16_t domain_port) bool p3PeerMgrIMPL::setHiddenDomainPort(const RsPeerId &ssl_id, const std::string &domain_addr, const uint16_t domain_port)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
@ -414,7 +414,7 @@ bool p3PeerMgrIMPL::setHiddenDomainPort(const SSLIdType &ssl_id, const std::stri
} }
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
it = mFriendList.find(ssl_id); it = mFriendList.find(ssl_id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -453,12 +453,12 @@ bool p3PeerMgrIMPL::getProxyServerAddress(struct sockaddr_storage &proxy_addr)
return true; return true;
} }
bool p3PeerMgrIMPL::getProxyAddress(const SSLIdType &ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port) bool p3PeerMgrIMPL::getProxyAddress(const RsPeerId &ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
it = mFriendList.find(ssl_id); it = mFriendList.find(ssl_id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -478,7 +478,7 @@ bool p3PeerMgrIMPL::getProxyAddress(const SSLIdType &ssl_id, struct sockaddr_sto
} }
// Placeholder until we implement this functionality. // Placeholder until we implement this functionality.
uint32_t p3PeerMgrIMPL::getConnectionType(const SSLIdType &/*sslId*/) uint32_t p3PeerMgrIMPL::getConnectionType(const RsPeerId &/*sslId*/)
{ {
return RS_NET_CONN_TYPE_FRIEND; return RS_NET_CONN_TYPE_FRIEND;
} }
@ -487,7 +487,7 @@ int p3PeerMgrIMPL::getFriendCount(bool ssl, bool online)
{ {
if (online) { if (online) {
// count only online id's // count only online id's
std::list<SSLIdType> onlineIds; std::list<RsPeerId> onlineIds;
mLinkMgr->getOnlineList(onlineIds); mLinkMgr->getOnlineList(onlineIds);
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
@ -495,7 +495,7 @@ int p3PeerMgrIMPL::getFriendCount(bool ssl, bool online)
std::set<PGPIdType> gpgIds; std::set<PGPIdType> gpgIds;
int count = 0; int count = 0;
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); ++it) { for(it = mFriendList.begin(); it != mFriendList.end(); ++it) {
if (online && std::find(onlineIds.begin(), onlineIds.end(), it->first) == onlineIds.end()) { if (online && std::find(onlineIds.begin(), onlineIds.end(), it->first) == onlineIds.end()) {
continue; continue;
@ -523,18 +523,18 @@ int p3PeerMgrIMPL::getFriendCount(bool ssl, bool online)
AuthGPG::getAuthGPG()->getGPGAcceptedList(gpgIds); AuthGPG::getAuthGPG()->getGPGAcceptedList(gpgIds);
// add own gpg id, if we have more than one location // add own gpg id, if we have more than one location
std::list<SSLIdType> ownSslIds; std::list<RsPeerId> ownSslIds;
getAssociatedPeers(AuthGPG::getAuthGPG()->getGPGOwnId(), ownSslIds); getAssociatedPeers(AuthGPG::getAuthGPG()->getGPGOwnId(), ownSslIds);
return gpgIds.size() + ((ownSslIds.size() > 0) ? 1 : 0); return gpgIds.size() + ((ownSslIds.size() > 0) ? 1 : 0);
} }
bool p3PeerMgrIMPL::getFriendNetStatus(const SSLIdType &id, peerState &state) bool p3PeerMgrIMPL::getFriendNetStatus(const RsPeerId &id, peerState &state)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
it = mFriendList.find(id); it = mFriendList.find(id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -546,12 +546,12 @@ bool p3PeerMgrIMPL::getFriendNetStatus(const SSLIdType &id, peerState &state)
} }
bool p3PeerMgrIMPL::getOthersNetStatus(const SSLIdType &id, peerState &state) bool p3PeerMgrIMPL::getOthersNetStatus(const RsPeerId &id, peerState &state)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
it = mOthersList.find(id); it = mOthersList.find(id);
if (it == mOthersList.end()) if (it == mOthersList.end())
{ {
@ -562,7 +562,7 @@ bool p3PeerMgrIMPL::getOthersNetStatus(const SSLIdType &id, peerState &state)
return true; return true;
} }
int p3PeerMgrIMPL::getConnectAddresses(const SSLIdType &id, int p3PeerMgrIMPL::getConnectAddresses(const RsPeerId &id,
struct sockaddr_storage &lAddr, struct sockaddr_storage &eAddr, struct sockaddr_storage &lAddr, struct sockaddr_storage &eAddr,
pqiIpAddrSet &histAddrs, std::string &dyndns) pqiIpAddrSet &histAddrs, std::string &dyndns)
{ {
@ -570,7 +570,7 @@ int p3PeerMgrIMPL::getConnectAddresses(const SSLIdType &id,
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
it = mFriendList.find(id); it = mFriendList.find(id);
if (it == mFriendList.end()) if (it == mFriendList.end())
{ {
@ -595,7 +595,7 @@ bool p3PeerMgrIMPL::haveOnceConnected()
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check for existing */ /* check for existing */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
if (it->second.lastcontact > 0) if (it->second.lastcontact > 0)
@ -623,10 +623,10 @@ bool p3PeerMgrIMPL::haveOnceConnected()
/*******************************************************************/ /*******************************************************************/
/*******************************************************************/ /*******************************************************************/
bool p3PeerMgrIMPL::addFriend(const SSLIdType& input_id, const PGPIdType& input_gpg_id, uint32_t netMode, uint16_t vs_disc, uint16_t vs_dht, time_t lastContact,ServicePermissionFlags service_flags) bool p3PeerMgrIMPL::addFriend(const RsPeerId& input_id, const PGPIdType& input_gpg_id, uint32_t netMode, uint16_t vs_disc, uint16_t vs_dht, time_t lastContact,ServicePermissionFlags service_flags)
{ {
bool notifyLinkMgr = false; bool notifyLinkMgr = false;
SSLIdType id = input_id ; RsPeerId id = input_id ;
PGPIdType gpg_id = input_gpg_id ; PGPIdType gpg_id = input_gpg_id ;
rslog(RSL_WARNING, p3peermgrzone, "p3PeerMgr::addFriend() id: " + id.toStdString()); rslog(RSL_WARNING, p3peermgrzone, "p3PeerMgr::addFriend() id: " + id.toStdString());
@ -653,7 +653,7 @@ bool p3PeerMgrIMPL::addFriend(const SSLIdType& input_id, const PGPIdType& input_
std::cerr << "p3PeerMgrIMPL::addFriend() " << id << "; gpg_id : " << gpg_id << std::endl; std::cerr << "p3PeerMgrIMPL::addFriend() " << id << "; gpg_id : " << gpg_id << std::endl;
#endif #endif
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() != mFriendList.find(id)) if (mFriendList.end() != mFriendList.find(id))
{ {
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
@ -748,7 +748,7 @@ bool p3PeerMgrIMPL::addFriend(const SSLIdType& input_id, const PGPIdType& input_
} }
bool p3PeerMgrIMPL::removeFriend(const SSLIdType &id, bool removePgpId) bool p3PeerMgrIMPL::removeFriend(const RsPeerId &id, bool removePgpId)
{ {
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
@ -758,7 +758,7 @@ bool p3PeerMgrIMPL::removeFriend(const SSLIdType &id, bool removePgpId)
rslog(RSL_WARNING, p3peermgrzone, "p3PeerMgr::removeFriend() id: " + id); rslog(RSL_WARNING, p3peermgrzone, "p3PeerMgr::removeFriend() id: " + id);
std::list<SSLIdType> sslid_toRemove; // This is a list of SSLIds. std::list<RsPeerId> sslid_toRemove; // This is a list of SSLIds.
std::list<PGPIdType> pgpid_toRemove; // This is a list of SSLIds. std::list<PGPIdType> pgpid_toRemove; // This is a list of SSLIds.
{ {
@ -766,7 +766,7 @@ bool p3PeerMgrIMPL::removeFriend(const SSLIdType &id, bool removePgpId)
/* move to othersList */ /* move to othersList */
bool success = false; bool success = false;
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
//remove ssl and gpg_ids //remove ssl and gpg_ids
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
@ -787,7 +787,7 @@ bool p3PeerMgrIMPL::removeFriend(const SSLIdType &id, bool removePgpId)
} }
} }
std::list<SSLIdType>::iterator rit; std::list<RsPeerId>::iterator rit;
for(rit = sslid_toRemove.begin(); rit != sslid_toRemove.end(); rit++) for(rit = sslid_toRemove.begin(); rit != sslid_toRemove.end(); rit++)
if (mFriendList.end() != (it = mFriendList.find(*rit))) if (mFriendList.end() != (it = mFriendList.find(*rit)))
mFriendList.erase(it); mFriendList.erase(it);
@ -803,14 +803,14 @@ bool p3PeerMgrIMPL::removeFriend(const SSLIdType &id, bool removePgpId)
#endif #endif
} }
std::list<SSLIdType>::iterator rit; std::list<RsPeerId>::iterator rit;
for(rit = sslid_toRemove.begin(); rit != sslid_toRemove.end(); rit++) for(rit = sslid_toRemove.begin(); rit != sslid_toRemove.end(); rit++)
{ {
mLinkMgr->removeFriend(*rit); mLinkMgr->removeFriend(*rit);
} }
/* remove id from all groups */ /* remove id from all groups */
std::list<SSLIdType> peerIds; std::list<RsPeerId> peerIds;
peerIds.push_back(id); peerIds.push_back(id);
assignPeersToGroup("", peerIds, false); assignPeersToGroup("", peerIds, false);
@ -835,7 +835,7 @@ void p3PeerMgrIMPL::printPeerLists(std::ostream &out)
out << std::endl; out << std::endl;
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
out << "\t SSL ID: " << it->second.id; out << "\t SSL ID: " << it->second.id;
@ -948,7 +948,7 @@ bool p3PeerMgrIMPL::UpdateOwnAddress(const struct sockaddr_storage &localAddr,
bool p3PeerMgrIMPL::setLocalAddress(const SSLIdType &id, const struct sockaddr_storage &addr) bool p3PeerMgrIMPL::setLocalAddress(const RsPeerId &id, const struct sockaddr_storage &addr)
{ {
bool changed = false; bool changed = false;
@ -975,7 +975,7 @@ bool p3PeerMgrIMPL::setLocalAddress(const SSLIdType &id, const struct sockadd
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
if (mOthersList.end() == (it = mOthersList.find(id))) if (mOthersList.end() == (it = mOthersList.find(id)))
@ -1009,7 +1009,7 @@ bool p3PeerMgrIMPL::setLocalAddress(const SSLIdType &id, const struct sockadd
return changed; return changed;
} }
bool p3PeerMgrIMPL::setExtAddress(const SSLIdType &id, const struct sockaddr_storage &addr) bool p3PeerMgrIMPL::setExtAddress(const RsPeerId &id, const struct sockaddr_storage &addr)
{ {
bool changed = false; bool changed = false;
@ -1031,7 +1031,7 @@ bool p3PeerMgrIMPL::setExtAddress(const SSLIdType &id, const struct sockaddr_
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
if (mOthersList.end() == (it = mOthersList.find(id))) if (mOthersList.end() == (it = mOthersList.find(id)))
@ -1066,7 +1066,7 @@ bool p3PeerMgrIMPL::setExtAddress(const SSLIdType &id, const struct sockaddr_
} }
bool p3PeerMgrIMPL::setDynDNS(const SSLIdType &id, const std::string &dyndns) bool p3PeerMgrIMPL::setDynDNS(const RsPeerId &id, const std::string &dyndns)
{ {
bool changed = false; bool changed = false;
@ -1084,7 +1084,7 @@ bool p3PeerMgrIMPL::setDynDNS(const SSLIdType &id, const std::string &dyndns)
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
if (mOthersList.end() == (it = mOthersList.find(id))) if (mOthersList.end() == (it = mOthersList.find(id)))
@ -1106,7 +1106,7 @@ bool p3PeerMgrIMPL::setDynDNS(const SSLIdType &id, const std::string &dyndns)
return changed; return changed;
} }
bool p3PeerMgrIMPL::updateAddressList(const SSLIdType& id, const pqiIpAddrSet &addrs) bool p3PeerMgrIMPL::updateAddressList(const RsPeerId& id, const pqiIpAddrSet &addrs)
{ {
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::setAddressList() called for id : " << id << std::endl; std::cerr << "p3PeerMgrIMPL::setAddressList() called for id : " << id << std::endl;
@ -1122,7 +1122,7 @@ bool p3PeerMgrIMPL::updateAddressList(const SSLIdType& id, const pqiIpAddrSet
} }
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
if (mOthersList.end() == (it = mOthersList.find(id))) if (mOthersList.end() == (it = mOthersList.find(id)))
@ -1151,7 +1151,7 @@ bool p3PeerMgrIMPL::updateAddressList(const SSLIdType& id, const pqiIpAddrSet
} }
bool p3PeerMgrIMPL::updateCurrentAddress(const SSLIdType& id, const pqiIpAddress &addr) bool p3PeerMgrIMPL::updateCurrentAddress(const RsPeerId& id, const pqiIpAddress &addr)
{ {
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::updateCurrentAddress() called for id : " << id << std::endl; std::cerr << "p3PeerMgrIMPL::updateCurrentAddress() called for id : " << id << std::endl;
@ -1162,7 +1162,7 @@ bool p3PeerMgrIMPL::updateCurrentAddress(const SSLIdType& id, const pqiIpAddr
/* cannot be own id */ /* cannot be own id */
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
if (mOthersList.end() == (it = mOthersList.find(id))) if (mOthersList.end() == (it = mOthersList.find(id)))
@ -1198,7 +1198,7 @@ bool p3PeerMgrIMPL::updateCurrentAddress(const SSLIdType& id, const pqiIpAddr
} }
bool p3PeerMgrIMPL::updateLastContact(const SSLIdType& id) bool p3PeerMgrIMPL::updateLastContact(const RsPeerId& id)
{ {
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::updateLastContact() called for id : " << id << std::endl; std::cerr << "p3PeerMgrIMPL::updateLastContact() called for id : " << id << std::endl;
@ -1209,7 +1209,7 @@ bool p3PeerMgrIMPL::updateLastContact(const SSLIdType& id)
/* cannot be own id */ /* cannot be own id */
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
if (mOthersList.end() == (it = mOthersList.find(id))) if (mOthersList.end() == (it = mOthersList.find(id)))
@ -1226,7 +1226,7 @@ bool p3PeerMgrIMPL::updateLastContact(const SSLIdType& id)
return true; return true;
} }
bool p3PeerMgrIMPL::setNetworkMode(const SSLIdType &id, uint32_t netMode) bool p3PeerMgrIMPL::setNetworkMode(const RsPeerId &id, uint32_t netMode)
{ {
if (id == AuthSSL::getAuthSSL()->OwnId()) if (id == AuthSSL::getAuthSSL()->OwnId())
{ {
@ -1235,7 +1235,7 @@ bool p3PeerMgrIMPL::setNetworkMode(const SSLIdType &id, uint32_t netMode)
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
if (mOthersList.end() == (it = mOthersList.find(id))) if (mOthersList.end() == (it = mOthersList.find(id)))
@ -1257,7 +1257,7 @@ bool p3PeerMgrIMPL::setNetworkMode(const SSLIdType &id, uint32_t netMode)
return changed; return changed;
} }
bool p3PeerMgrIMPL::setLocation(const SSLIdType &id, const std::string &location) bool p3PeerMgrIMPL::setLocation(const RsPeerId &id, const std::string &location)
{ {
bool changed = false; bool changed = false;
@ -1276,7 +1276,7 @@ bool p3PeerMgrIMPL::setLocation(const SSLIdType &id, const std::string &locat
} }
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() != (it = mFriendList.find(id))) { if (mFriendList.end() != (it = mFriendList.find(id))) {
if (it->second.location.compare(location) != 0) { if (it->second.location.compare(location) != 0) {
it->second.location = location; it->second.location = location;
@ -1286,7 +1286,7 @@ bool p3PeerMgrIMPL::setLocation(const SSLIdType &id, const std::string &locat
return changed; return changed;
} }
bool p3PeerMgrIMPL::setVisState(const SSLIdType &id, uint16_t vs_disc, uint16_t vs_dht) bool p3PeerMgrIMPL::setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht)
{ {
{ {
std::string out; std::string out;
@ -1305,7 +1305,7 @@ bool p3PeerMgrIMPL::setVisState(const SSLIdType &id, uint16_t vs_disc, uint16
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* check if it is a friend */ /* check if it is a friend */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
if (mFriendList.end() == (it = mFriendList.find(id))) if (mFriendList.end() == (it = mFriendList.find(id)))
{ {
if (mOthersList.end() == (it = mOthersList.find(id))) if (mOthersList.end() == (it = mOthersList.find(id)))
@ -1453,7 +1453,7 @@ bool p3PeerMgrIMPL::saveList(bool &cleanup, std::list<RsItem *>& saveData)
saveCleanupList.push_back(item); saveCleanupList.push_back(item);
/* iterate through all friends and save */ /* iterate through all friends and save */
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
item = new RsPeerNetItem(); item = new RsPeerNetItem();
@ -1567,7 +1567,7 @@ bool p3PeerMgrIMPL::loadList(std::list<RsItem *>& load)
std::cerr << "p3PeerMgrIMPL::loadList() Item Count: " << load.size() << std::endl; std::cerr << "p3PeerMgrIMPL::loadList() Item Count: " << load.size() << std::endl;
#endif #endif
SSLIdType ownId = getOwnId(); RsPeerId ownId = getOwnId();
/* load the list of peers */ /* load the list of peers */
std::list<RsItem *>::iterator it; std::list<RsItem *>::iterator it;
@ -1952,7 +1952,7 @@ bool p3PeerMgrIMPL::getGroupInfoList(std::list<RsGroupInfo> &groupInfoList)
} }
// groupId == "" && assign == false -> remove from all groups // groupId == "" && assign == false -> remove from all groups
bool p3PeerMgrIMPL::assignPeersToGroup(const std::string &groupId, const std::list<SSLIdType> &peerIds, bool assign) bool p3PeerMgrIMPL::assignPeersToGroup(const std::string &groupId, const std::list<RsPeerId> &peerIds, bool assign)
{ {
if (groupId.empty() && assign == true) { if (groupId.empty() && assign == true) {
return false; return false;
@ -1972,9 +1972,9 @@ bool p3PeerMgrIMPL::assignPeersToGroup(const std::string &groupId, const std::li
if (groupId.empty() || (*groupIt)->id == groupId) { if (groupId.empty() || (*groupIt)->id == groupId) {
RsPeerGroupItem *groupItem = *groupIt; RsPeerGroupItem *groupItem = *groupIt;
std::list<std::string>::const_iterator peerIt; std::list<RsPeerId>::const_iterator peerIt;
for (peerIt = peerIds.begin(); peerIt != peerIds.end(); peerIt++) { for (peerIt = peerIds.begin(); peerIt != peerIds.end(); peerIt++) {
std::list<std::string>::iterator peerIt1 = std::find(groupItem->peerIds.begin(), groupItem->peerIds.end(), *peerIt); std::list<RsPeerId>::iterator peerIt1 = std::find(groupItem->peerIds.begin(), groupItem->peerIds.end(), *peerIt);
if (assign) { if (assign) {
if (peerIt1 == groupItem->peerIds.end()) { if (peerIt1 == groupItem->peerIds.end()) {
groupItem->peerIds.push_back(*peerIt); groupItem->peerIds.push_back(*peerIt);
@ -2011,19 +2011,14 @@ bool p3PeerMgrIMPL::assignPeersToGroup(const std::string &groupId, const std::li
********************************************************************** **********************************************************************
**********************************************************************/ **********************************************************************/
ServicePermissionFlags p3PeerMgrIMPL::servicePermissionFlags_sslid(const SSLIdType& ssl_id) ServicePermissionFlags p3PeerMgrIMPL::servicePermissionFlags(const RsPeerId& ssl_id)
{ {
PGPIdType gpg_id ; PGPIdType gpg_id ;
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
if(ssl_id.length() != 32) std::map<RsPeerId, peerState>::const_iterator it = mFriendList.find(ssl_id);
{
std::cerr << "(EE) p3PeerMgrIMPL::servicePermissionFlags_sslid() called with inconsistent id " << ssl_id << std::endl;
return RS_SERVICE_PERM_ALL ;
}
std::map<SSLIdType, peerState>::const_iterator it = mFriendList.find(ssl_id);
if(it == mFriendList.end()) if(it == mFriendList.end())
return RS_SERVICE_PERM_ALL ; return RS_SERVICE_PERM_ALL ;
@ -2037,13 +2032,6 @@ ServicePermissionFlags p3PeerMgrIMPL::servicePermissionFlags_sslid(const SSLIdTy
ServicePermissionFlags p3PeerMgrIMPL::servicePermissionFlags(const PGPIdType& pgp_id) ServicePermissionFlags p3PeerMgrIMPL::servicePermissionFlags(const PGPIdType& pgp_id)
{ {
//
if(pgp_id.length() != 16)
{
std::cerr << "(EE) p3PeerMgrIMPL::servicePermissionFlags() called with inconsistent id " << pgp_id << std::endl;
return RS_SERVICE_PERM_ALL ;
}
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
@ -2062,11 +2050,6 @@ void p3PeerMgrIMPL::setServicePermissionFlags(const PGPIdType& pgp_id, const Ser
// Check that we have a PGP id. This should not be necessary, but because // Check that we have a PGP id. This should not be necessary, but because
// we use std::string, anything can get passed down here. // we use std::string, anything can get passed down here.
// //
if(pgp_id.length() != 16)
{
std::cerr << "Bad parameter passed to setServicePermissionFlags(): " << pgp_id << std::endl;
return ;
}
mFriendsPermissionFlags[pgp_id] = flags ; mFriendsPermissionFlags[pgp_id] = flags ;
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/ IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
@ -2080,13 +2063,13 @@ void p3PeerMgrIMPL::setServicePermissionFlags(const PGPIdType& pgp_id, const Ser
bool p3PeerMgrIMPL::removeAllFriendLocations(const PGPIdType &gpgid) bool p3PeerMgrIMPL::removeAllFriendLocations(const PGPIdType &gpgid)
{ {
std::list<SSLIdType> sslIds; std::list<RsPeerId> sslIds;
if (!getAssociatedPeers(gpgid, sslIds)) if (!getAssociatedPeers(gpgid, sslIds))
{ {
return false; return false;
} }
std::list<SSLIdType>::iterator it; std::list<RsPeerId>::iterator it;
for(it = sslIds.begin(); it != sslIds.end(); it++) for(it = sslIds.begin(); it != sslIds.end(); it++)
{ {
removeFriend(*it, true); removeFriend(*it, true);
@ -2096,7 +2079,7 @@ bool p3PeerMgrIMPL::removeAllFriendLocations(const PGPIdType &gpgid)
} }
bool p3PeerMgrIMPL::getAssociatedPeers(const PGPIdType &gpg_id, std::list<SSLIdType> &ids) bool p3PeerMgrIMPL::getAssociatedPeers(const PGPIdType &gpg_id, std::list<RsPeerId> &ids)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
@ -2105,7 +2088,7 @@ bool p3PeerMgrIMPL::getAssociatedPeers(const PGPIdType &gpg_id, std::list<SSLIdT
#endif #endif
int count = 0; int count = 0;
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
if (it->second.gpg_id == gpg_id) if (it->second.gpg_id == gpg_id)
@ -2126,20 +2109,20 @@ bool p3PeerMgrIMPL::getAssociatedPeers(const PGPIdType &gpg_id, std::list<SSLIdT
/* This only removes SSL certs, that are old... Can end up with no Certs per GPG Id // /* 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. // * We are removing the concept of a "DummyId" - There is no need for it.
*/ // */
//
bool isDummyFriend(SSLIdType id) // bool isDummyFriend(RsPeerId id)
{ // {
bool ret = (id.substr(0,5) == "dummy"); // bool ret = (id.substr(0,5) == "dummy");
return ret; // return ret;
} // }
bool p3PeerMgrIMPL::removeUnusedLocations() bool p3PeerMgrIMPL::removeUnusedLocations()
{ {
std::list<SSLIdType> toRemove; std::list<RsPeerId> toRemove;
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
@ -2150,7 +2133,7 @@ bool p3PeerMgrIMPL::removeUnusedLocations()
time_t now = time(NULL); time_t now = time(NULL);
std::map<SSLIdType, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
for(it = mFriendList.begin(); it != mFriendList.end(); it++) for(it = mFriendList.begin(); it != mFriendList.end(); it++)
{ {
if (now - it->second.lastcontact > VERY_OLD_PEER) if (now - it->second.lastcontact > VERY_OLD_PEER)
@ -2163,19 +2146,19 @@ bool p3PeerMgrIMPL::removeUnusedLocations()
} }
if (isDummyFriend(it->first)) // if (isDummyFriend(it->first))
{ // {
toRemove.push_back(it->first); // toRemove.push_back(it->first);
//
#ifdef P3PEERS_DEBUG //#ifdef P3PEERS_DEBUG
std::cerr << "p3PeerMgr::removeUnusedLocations() removing Dummy Id: " << it->first << std::endl; // std::cerr << "p3PeerMgr::removeUnusedLocations() removing Dummy Id: " << it->first << std::endl;
#endif //#endif
//
} // }
} }
} }
std::list<SSLIdType>::iterator it; std::list<RsPeerId>::iterator it;
for(it = toRemove.begin(); it != toRemove.end(); it++) for(it = toRemove.begin(); it != toRemove.end(); it++)
{ {

108
libretroshare/src/pqi/p3peermgr.h
View file

@ -70,7 +70,7 @@ class peerState
public: public:
peerState(); /* init */ peerState(); /* init */
SSLIdType id; RsPeerId id;
PGPIdType gpg_id; PGPIdType gpg_id;
uint32_t netMode; /* EXT / UPNP / UDP / HIDDEN / INVALID */ uint32_t netMode; /* EXT / UPNP / UDP / HIDDEN / INVALID */
@ -114,14 +114,14 @@ class p3PeerMgr
p3PeerMgr() { return; } p3PeerMgr() { return; }
virtual ~p3PeerMgr() { return; } virtual ~p3PeerMgr() { return; }
virtual bool addFriend(const SSLIdType &ssl_id, const PGPIdType &gpg_id, uint32_t netMode = RS_NET_MODE_UDP, virtual bool addFriend(const RsPeerId &ssl_id, const PGPIdType &gpg_id, uint32_t netMode = RS_NET_MODE_UDP,
uint16_t vsDisc = RS_VS_DISC_FULL, uint16_t vsDht = RS_VS_DHT_FULL, uint16_t vsDisc = RS_VS_DISC_FULL, uint16_t vsDht = RS_VS_DHT_FULL,
time_t lastContact = 0,ServicePermissionFlags = ServicePermissionFlags(RS_SERVICE_PERM_ALL)) = 0; time_t lastContact = 0,ServicePermissionFlags = ServicePermissionFlags(RS_SERVICE_PERM_ALL)) = 0;
virtual bool removeFriend(const SSLIdType &ssl_id, bool removePgpId) = 0; virtual bool removeFriend(const RsPeerId &ssl_id, bool removePgpId) = 0;
virtual bool isFriend(const SSLIdType& ssl_id) = 0; virtual bool isFriend(const RsPeerId& ssl_id) = 0;
virtual bool getAssociatedPeers(const PGPIdType &gpg_id, std::list<SSLIdType> &ids) = 0; virtual bool getAssociatedPeers(const PGPIdType &gpg_id, std::list<RsPeerId> &ids) = 0;
virtual bool removeAllFriendLocations(const PGPIdType &gpgid) = 0; virtual bool removeAllFriendLocations(const PGPIdType &gpgid) = 0;
@ -133,10 +133,10 @@ virtual bool editGroup(const std::string &groupId, RsGroupInfo &groupInfo) =
virtual bool removeGroup(const std::string &groupId) = 0; virtual bool removeGroup(const std::string &groupId) = 0;
virtual bool getGroupInfo(const std::string &groupId, RsGroupInfo &groupInfo) = 0; virtual bool getGroupInfo(const std::string &groupId, RsGroupInfo &groupInfo) = 0;
virtual bool getGroupInfoList(std::list<RsGroupInfo> &groupInfoList) = 0; virtual bool getGroupInfoList(std::list<RsGroupInfo> &groupInfoList) = 0;
virtual bool assignPeersToGroup(const std::string &groupId, const std::list<SSLIdType> &peerIds, bool assign) = 0; virtual bool assignPeersToGroup(const std::string &groupId, const std::list<RsPeerId> &peerIds, bool assign) = 0;
virtual ServicePermissionFlags servicePermissionFlags(const PGPIdType& gpg_id) =0; virtual ServicePermissionFlags servicePermissionFlags(const PGPIdType& gpg_id) =0;
virtual ServicePermissionFlags servicePermissionFlags(const SSLIdType& ssl_id) =0; virtual ServicePermissionFlags servicePermissionFlags(const RsPeerId& ssl_id) =0;
virtual void setServicePermissionFlags(const PGPIdType& gpg_id,const ServicePermissionFlags& flags) =0; virtual void setServicePermissionFlags(const PGPIdType& gpg_id,const ServicePermissionFlags& flags) =0;
/**************** Set Net Info ****************/ /**************** Set Net Info ****************/
@ -147,19 +147,19 @@ virtual bool assignPeersToGroup(const std::string &groupId, const std::list<S
* 3) p3disc - reasonable * 3) p3disc - reasonable
*/ */
virtual bool setLocalAddress(const SSLIdType &id, const struct sockaddr_storage &addr) = 0; virtual bool setLocalAddress(const RsPeerId &id, const struct sockaddr_storage &addr) = 0;
virtual bool setExtAddress(const SSLIdType &id, const struct sockaddr_storage &addr) = 0; virtual bool setExtAddress(const RsPeerId &id, const struct sockaddr_storage &addr) = 0;
virtual bool setDynDNS(const SSLIdType &id, const std::string &dyndns) = 0; virtual bool setDynDNS(const RsPeerId &id, const std::string &dyndns) = 0;
virtual bool setNetworkMode(const SSLIdType &id, uint32_t netMode) = 0; virtual bool setNetworkMode(const RsPeerId &id, uint32_t netMode) = 0;
virtual bool setVisState(const SSLIdType &id, uint16_t vs_disc, uint16_t vs_dht) = 0; virtual bool setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht) = 0;
virtual bool setLocation(const SSLIdType &pid, const std::string &location) = 0; virtual bool setLocation(const RsPeerId &pid, const std::string &location) = 0;
virtual bool setHiddenDomainPort(const SSLIdType &id, const std::string &domain_addr, const uint16_t domain_port) = 0; virtual bool setHiddenDomainPort(const RsPeerId &id, const std::string &domain_addr, const uint16_t domain_port) = 0;
virtual bool updateCurrentAddress(const SSLIdType& id, const pqiIpAddress &addr) = 0; virtual bool updateCurrentAddress(const RsPeerId& id, const pqiIpAddress &addr) = 0;
virtual bool updateLastContact(const SSLIdType& id) = 0; virtual bool updateLastContact(const RsPeerId& id) = 0;
virtual bool updateAddressList(const SSLIdType& id, const pqiIpAddrSet &addrs) = 0; virtual bool updateAddressList(const RsPeerId& id, const pqiIpAddrSet &addrs) = 0;
// THIS MUST ONLY BE CALLED BY NETMGR!!!! // THIS MUST ONLY BE CALLED BY NETMGR!!!!
@ -175,18 +175,18 @@ virtual bool UpdateOwnAddress(const struct sockaddr_storage &local_addr, cons
*/ */
virtual bool getOwnNetStatus(peerState &state) = 0; virtual bool getOwnNetStatus(peerState &state) = 0;
virtual bool getFriendNetStatus(const SSLIdType &id, peerState &state) = 0; virtual bool getFriendNetStatus(const RsPeerId &id, peerState &state) = 0;
virtual bool getOthersNetStatus(const SSLIdType &id, peerState &state) = 0; virtual bool getOthersNetStatus(const RsPeerId &id, peerState &state) = 0;
virtual bool getPeerName(const SSLIdType &ssl_id, std::string &name) = 0; virtual bool getPeerName(const RsPeerId &ssl_id, std::string &name) = 0;
virtual bool getGpgId(const SSLIdType &sslId, PGPIdType &gpgId) = 0; virtual bool getGpgId(const RsPeerId &sslId, PGPIdType &gpgId) = 0;
virtual uint32_t getConnectionType(const SSLIdType &sslId) = 0; virtual uint32_t getConnectionType(const RsPeerId &sslId) = 0;
virtual bool setProxyServerAddress(const struct sockaddr_storage &proxy_addr) = 0; virtual bool setProxyServerAddress(const struct sockaddr_storage &proxy_addr) = 0;
virtual bool getProxyServerAddress(struct sockaddr_storage &proxy_addr) = 0; virtual bool getProxyServerAddress(struct sockaddr_storage &proxy_addr) = 0;
virtual bool isHidden() = 0; virtual bool isHidden() = 0;
virtual bool isHiddenPeer(const SSLIdType &ssl_id) = 0; virtual bool isHiddenPeer(const RsPeerId &ssl_id) = 0;
virtual bool getProxyAddress(const SSLIdType &ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port) = 0; virtual bool getProxyAddress(const RsPeerId &ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port) = 0;
virtual int getFriendCount(bool ssl, bool online) = 0; virtual int getFriendCount(bool ssl, bool online) = 0;
@ -214,14 +214,14 @@ class p3PeerMgrIMPL: public p3PeerMgr, public p3Config
/* EXTERNAL INTERFACE */ /* EXTERNAL INTERFACE */
/************************************************************************************************/ /************************************************************************************************/
virtual bool addFriend(const SSLIdType&ssl_id, const PGPIdType&gpg_id, uint32_t netMode = RS_NET_MODE_UDP, virtual bool addFriend(const RsPeerId&ssl_id, const PGPIdType&gpg_id, uint32_t netMode = RS_NET_MODE_UDP,
uint16_t vsDisc = RS_VS_DISC_FULL, uint16_t vsDht = RS_VS_DHT_FULL, uint16_t vsDisc = RS_VS_DISC_FULL, uint16_t vsDht = RS_VS_DHT_FULL,
time_t lastContact = 0,ServicePermissionFlags = ServicePermissionFlags(RS_SERVICE_PERM_ALL)); time_t lastContact = 0,ServicePermissionFlags = ServicePermissionFlags(RS_SERVICE_PERM_ALL));
virtual bool removeFriend(const SSLIdType &ssl_id, bool removePgpId); virtual bool removeFriend(const RsPeerId &ssl_id, bool removePgpId);
virtual bool isFriend(const SSLIdType &ssl_id); virtual bool isFriend(const RsPeerId &ssl_id);
virtual bool getAssociatedPeers(const PGPIdType &gpg_id, std::list<SSLIdType> &ids); virtual bool getAssociatedPeers(const PGPIdType &gpg_id, std::list<RsPeerId> &ids);
virtual bool removeAllFriendLocations(const PGPIdType &gpgid); virtual bool removeAllFriendLocations(const PGPIdType &gpgid);
@ -233,11 +233,11 @@ virtual bool editGroup(const std::string &groupId, RsGroupInfo &groupInfo);
virtual bool removeGroup(const std::string &groupId); virtual bool removeGroup(const std::string &groupId);
virtual bool getGroupInfo(const std::string &groupId, RsGroupInfo &groupInfo); virtual bool getGroupInfo(const std::string &groupId, RsGroupInfo &groupInfo);
virtual bool getGroupInfoList(std::list<RsGroupInfo> &groupInfoList); virtual bool getGroupInfoList(std::list<RsGroupInfo> &groupInfoList);
virtual bool assignPeersToGroup(const std::string &groupId, const std::list<std::string> &peerIds, bool assign); virtual bool assignPeersToGroup(const std::string &groupId, const std::list<RsPeerId> &peerIds, bool assign);
virtual ServicePermissionFlags servicePermissionFlags(const std::string& gpg_id) ; virtual ServicePermissionFlags servicePermissionFlags(const PGPIdType& gpg_id) ;
virtual ServicePermissionFlags servicePermissionFlags_sslid(const std::string& ssl_id) ; virtual ServicePermissionFlags servicePermissionFlags(const RsPeerId& ssl_id) ;
virtual void setServicePermissionFlags(const std::string& gpg_id,const ServicePermissionFlags& flags) ; virtual void setServicePermissionFlags(const PGPIdType& gpg_id,const ServicePermissionFlags& flags) ;
/**************** Set Net Info ****************/ /**************** Set Net Info ****************/
/* /*
@ -247,19 +247,19 @@ virtual bool assignPeersToGroup(const std::string &groupId, const std::list<s
* 3) p3disc - reasonable * 3) p3disc - reasonable
*/ */
virtual bool setLocalAddress(const SSLIdType &id, const struct sockaddr_storage &addr); virtual bool setLocalAddress(const RsPeerId &id, const struct sockaddr_storage &addr);
virtual bool setExtAddress(const SSLIdType &id, const struct sockaddr_storage &addr); virtual bool setExtAddress(const RsPeerId &id, const struct sockaddr_storage &addr);
virtual bool setDynDNS(const SSLIdType &id, const std::string &dyndns); virtual bool setDynDNS(const RsPeerId &id, const std::string &dyndns);
virtual bool setNetworkMode(const SSLIdType &id, uint32_t netMode); virtual bool setNetworkMode(const RsPeerId &id, uint32_t netMode);
virtual bool setVisState(const SSLIdType &id, uint16_t vs_disc, uint16_t vs_dht); virtual bool setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht);
virtual bool setLocation(const SSLIdType &pid, const std::string &location); virtual bool setLocation(const RsPeerId &pid, const std::string &location);
virtual bool setHiddenDomainPort(const SSLIdType &id, const std::string &domain_addr, const uint16_t domain_port); virtual bool setHiddenDomainPort(const RsPeerId &id, const std::string &domain_addr, const uint16_t domain_port);
virtual bool updateCurrentAddress(const SSLIdType& id, const pqiIpAddress &addr); virtual bool updateCurrentAddress(const RsPeerId& id, const pqiIpAddress &addr);
virtual bool updateLastContact(const SSLIdType& id); virtual bool updateLastContact(const RsPeerId& id);
virtual bool updateAddressList(const SSLIdType& id, const pqiIpAddrSet &addrs); virtual bool updateAddressList(const RsPeerId& id, const pqiIpAddrSet &addrs);
// THIS MUST ONLY BE CALLED BY NETMGR!!!! // THIS MUST ONLY BE CALLED BY NETMGR!!!!
@ -274,18 +274,18 @@ virtual bool UpdateOwnAddress(const struct sockaddr_storage &local_addr, cons
*/ */
virtual bool getOwnNetStatus(peerState &state); virtual bool getOwnNetStatus(peerState &state);
virtual bool getFriendNetStatus(const SSLIdType &id, peerState &state); virtual bool getFriendNetStatus(const RsPeerId &id, peerState &state);
virtual bool getOthersNetStatus(const SSLIdType &id, peerState &state); virtual bool getOthersNetStatus(const RsPeerId &id, peerState &state);
virtual bool getPeerName(const SSLIdType& ssl_id, std::string& name); virtual bool getPeerName(const RsPeerId& ssl_id, std::string& name);
virtual bool getGpgId(const SSLIdType& sslId, PGPIdType& gpgId); virtual bool getGpgId(const RsPeerId& sslId, PGPIdType& gpgId);
virtual uint32_t getConnectionType(const SSLIdType& sslId); virtual uint32_t getConnectionType(const RsPeerId& sslId);
virtual bool setProxyServerAddress(const struct sockaddr_storage &proxy_addr); virtual bool setProxyServerAddress(const struct sockaddr_storage &proxy_addr);
virtual bool getProxyServerAddress(struct sockaddr_storage &proxy_addr); virtual bool getProxyServerAddress(struct sockaddr_storage &proxy_addr);
virtual bool isHidden(); virtual bool isHidden();
virtual bool isHiddenPeer(const SSLIdType& ssl_id); virtual bool isHiddenPeer(const RsPeerId& ssl_id);
virtual bool getProxyAddress(const SSLIdType& ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port); virtual bool getProxyAddress(const RsPeerId& ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port);
virtual int getFriendCount(bool ssl, bool online); virtual int getFriendCount(bool ssl, bool online);
@ -299,7 +299,7 @@ virtual bool haveOnceConnected();
/* Extra IMPL Functions (used by p3LinkMgr, p3NetMgr + Setup) */ /* Extra IMPL Functions (used by p3LinkMgr, p3NetMgr + Setup) */
/************************************************************************************************/ /************************************************************************************************/
p3PeerMgrIMPL( const SSLIdType& ssl_own_id, p3PeerMgrIMPL( const RsPeerId& ssl_own_id,
const PGPIdType& gpg_own_id, const PGPIdType& gpg_own_id,
const std::string& gpg_own_name, const std::string& gpg_own_name,
const std::string& ssl_own_location) ; const std::string& ssl_own_location) ;
@ -311,11 +311,11 @@ bool setupHiddenNode(const std::string &hiddenAddress, const uint16_t hiddenPor
void tick(); void tick();
const SSLIdType& getOwnId(); const RsPeerId& getOwnId();
bool setOwnNetworkMode(uint32_t netMode); bool setOwnNetworkMode(uint32_t netMode);
bool setOwnVisState(uint16_t vs_disc, uint16_t vs_dht); bool setOwnVisState(uint16_t vs_disc, uint16_t vs_dht);
int getConnectAddresses(const SSLIdType &id, int getConnectAddresses(const RsPeerId &id,
struct sockaddr_storage &lAddr, struct sockaddr_storage &eAddr, struct sockaddr_storage &lAddr, struct sockaddr_storage &eAddr,
pqiIpAddrSet &histAddrs, std::string &dyndns); pqiIpAddrSet &histAddrs, std::string &dyndns);
@ -352,8 +352,8 @@ private:
peerState mOwnState; peerState mOwnState;
std::map<SSLIdType, peerState> mFriendList; // <SSLid , peerState> std::map<RsPeerId, peerState> mFriendList; // <SSLid , peerState>
std::map<SSLIdType, peerState> mOthersList; std::map<RsPeerId, peerState> mOthersList;
std::list<RsPeerGroupItem *> groupList; std::list<RsPeerGroupItem *> groupList;
uint32_t lastGroupId; uint32_t lastGroupId;

15
libretroshare/src/pqi/pqi_base.h
View file

@ -39,6 +39,7 @@
/*** Base DataTypes: ****/ /*** Base DataTypes: ****/
#include "serialiser/rsserial.h" #include "serialiser/rsserial.h"
#include "retroshare/rstypes.h"
#define PQI_MIN_PORT 10 // TO ALLOW USERS TO HAVE PORT 80! - was 1024 #define PQI_MIN_PORT 10 // TO ALLOW USERS TO HAVE PORT 80! - was 1024
@ -186,7 +187,7 @@ class NetInterface;
class PQInterface: public RateInterface class PQInterface: public RateInterface
{ {
public: public:
PQInterface(const std::string &id) :peerId(id) { return; } PQInterface(const RsPeerId &id) :peerId(id) { return; }
virtual ~PQInterface() { return; } virtual ~PQInterface() { return; }
/*! /*!
@ -221,7 +222,7 @@ class PQInterface: public RateInterface
*/ */
virtual int tick() { return 0; } virtual int tick() { return 0; }
virtual int status() { return 0; } virtual int status() { return 0; }
virtual std::string PeerId() { return peerId; } virtual const RsPeerId& PeerId() { return peerId; }
// the callback from NetInterface Connection Events. // the callback from NetInterface Connection Events.
virtual int notifyEvent(NetInterface *ni, int event, const struct sockaddr_storage &remote_peer_address) virtual int notifyEvent(NetInterface *ni, int event, const struct sockaddr_storage &remote_peer_address)
@ -234,7 +235,7 @@ class PQInterface: public RateInterface
private: private:
std::string peerId; RsPeerId peerId;
}; };
@ -353,7 +354,7 @@ public:
/** /**
* @param p_in used to notify system of connect/disconnect events * @param p_in used to notify system of connect/disconnect events
*/ */
NetInterface(PQInterface *p_in, std::string id) NetInterface(PQInterface *p_in, const RsPeerId& id)
:p(p_in), peerId(id) { return; } :p(p_in), peerId(id) { return; }
virtual ~NetInterface() virtual ~NetInterface()
@ -364,7 +365,7 @@ virtual int listen() = 0;
virtual int stoplistening() = 0; virtual int stoplistening() = 0;
virtual int disconnect() = 0; virtual int disconnect() = 0;
virtual int reset() = 0; virtual int reset() = 0;
virtual std::string PeerId() { return peerId; } virtual const RsPeerId& PeerId() { return peerId; }
virtual int getConnectAddress(struct sockaddr_storage &raddr) = 0; virtual int getConnectAddress(struct sockaddr_storage &raddr) = 0;
virtual bool connect_parameter(uint32_t type, uint32_t value) = 0; virtual bool connect_parameter(uint32_t type, uint32_t value) = 0;
@ -376,7 +377,7 @@ PQInterface *parent() { return p; }
private: private:
PQInterface *p; PQInterface *p;
std::string peerId; RsPeerId peerId;
}; };
//! network binary interface (abstract) //! network binary interface (abstract)
@ -390,7 +391,7 @@ private:
class NetBinInterface: public NetInterface, public BinInterface class NetBinInterface: public NetInterface, public BinInterface
{ {
public: public:
NetBinInterface(PQInterface *parent, std::string id) NetBinInterface(PQInterface *parent, const RsPeerId& id)
:NetInterface(parent, id) :NetInterface(parent, id)
{ return; } { return; }
virtual ~NetBinInterface() { return; } virtual ~NetBinInterface() { return; }

17
libretroshare/src/pqi/pqiassist.h
View file

@ -29,6 +29,7 @@
#include <string> #include <string>
#include <map> #include <map>
#include "retroshare/rstypes.h"
#include "pqi/pqinetwork.h" #include "pqi/pqinetwork.h"
#include "pqi/pqimonitor.h" #include "pqi/pqimonitor.h"
@ -109,7 +110,7 @@ class pqiNetAssistPeerShare
public: public:
/* share Addresses for various reasons (bad peers, etc) */ /* share Addresses for various reasons (bad peers, etc) */
virtual void updatePeer(std::string id, const struct sockaddr_storage &addr, int type, int reason, int age) = 0; virtual void updatePeer(const RsPeerId& id, const struct sockaddr_storage &addr, int type, int reason, int age) = 0;
}; };
@ -149,7 +150,7 @@ class pqiNetAssistConnect: public pqiNetAssist
/* /*
*/ */
public: public:
pqiNetAssistConnect(std::string id, pqiConnectCb *cb) pqiNetAssistConnect(const RsPeerId& id, pqiConnectCb *cb)
:mPeerId(id), mConnCb(cb) { return; } :mPeerId(id), mConnCb(cb) { return; }
/********** External DHT Interface ************************ /********** External DHT Interface ************************
@ -159,17 +160,17 @@ class pqiNetAssistConnect: public pqiNetAssist
/* add / remove peers */ /* add / remove peers */
virtual bool findPeer(std::string id) = 0; virtual bool findPeer(const RsPeerId& id) = 0;
virtual bool dropPeer(std::string id) = 0; virtual bool dropPeer(const RsPeerId& id) = 0;
/* add non-active peers (can still toggle active/non-active via above) */ /* add non-active peers (can still toggle active/non-active via above) */
virtual int addBadPeer(const struct sockaddr_storage &addr, uint32_t reason, uint32_t flags, uint32_t age) = 0; virtual int addBadPeer(const struct sockaddr_storage &addr, uint32_t reason, uint32_t flags, uint32_t age) = 0;
virtual int addKnownPeer(const std::string &pid, const struct sockaddr_storage &addr, uint32_t flags) = 0; virtual int addKnownPeer(const RsPeerId &pid, const struct sockaddr_storage &addr, uint32_t flags) = 0;
virtual void ConnectionFeedback(std::string pid, int mode) = 0; virtual void ConnectionFeedback(const RsPeerId& pid, int mode) = 0;
/* extract current peer status */ /* extract current peer status */
virtual bool getPeerStatus(std::string id, virtual bool getPeerStatus(const RsPeerId& id,
struct sockaddr_storage &laddr, struct sockaddr_storage &raddr, struct sockaddr_storage &laddr, struct sockaddr_storage &raddr,
uint32_t &type, uint32_t &mode) = 0; // DEPRECIATE. uint32_t &type, uint32_t &mode) = 0; // DEPRECIATE.
@ -179,7 +180,7 @@ virtual bool setAttachMode(bool on) = 0; // FIXUP.
virtual bool getNetworkStats(uint32_t &netsize, uint32_t &localnetsize) = 0; // DEPRECIATE. virtual bool getNetworkStats(uint32_t &netsize, uint32_t &localnetsize) = 0; // DEPRECIATE.
protected: protected:
std::string mPeerId; RsPeerId mPeerId;
pqiConnectCb *mConnCb; pqiConnectCb *mConnCb;
}; };

7
libretroshare/src/pqi/pqibin.cc
View file

@ -493,7 +493,7 @@ bool BinMemInterface::readfromfile(const char *fname)
/**************************************************************************/ /**************************************************************************/
void printNetBinID(std::ostream &out, std::string id, uint32_t t) void printNetBinID(std::ostream &out, const RsPeerId& id, uint32_t t)
{ {
out << "NetBinId(" << id << ","; out << "NetBinId(" << id << ",";
if (t == PQI_CONNECT_TCP) if (t == PQI_CONNECT_TCP)
@ -520,9 +520,8 @@ void printNetBinID(std::ostream &out, std::string id, uint32_t t)
const uint32_t DEFAULT_DUMMY_DELTA = 5; const uint32_t DEFAULT_DUMMY_DELTA = 5;
NetBinDummy::NetBinDummy(PQInterface *parent, std::string id, uint32_t t) NetBinDummy::NetBinDummy(PQInterface *parent, const RsPeerId& id, uint32_t t)
:NetBinInterface(parent, id), type(t), dummyConnected(false), :NetBinInterface(parent, id), type(t), dummyConnected(false), toConnect(false), connectDelta(DEFAULT_DUMMY_DELTA)
toConnect(false), connectDelta(DEFAULT_DUMMY_DELTA)
{ {
return; return;
} }

2
libretroshare/src/pqi/pqibin.h
View file

@ -195,7 +195,7 @@ virtual uint64_t bytecount();
class NetBinDummy: public NetBinInterface class NetBinDummy: public NetBinInterface
{ {
public: public:
NetBinDummy(PQInterface *parent, std::string id, uint32_t t); NetBinDummy(PQInterface *parent, const RsPeerId& id, uint32_t t);
virtual ~NetBinDummy() { return; } virtual ~NetBinDummy() { return; }
// Net Interface // Net Interface

6
libretroshare/src/pqi/pqihandler.cc
View file

@ -122,7 +122,7 @@ int pqihandler::status()
// display all interfaces... // display all interfaces...
for(it = mods.begin(); it != mods.end(); it++) for(it = mods.begin(); it != mods.end(); it++)
{ {
rs_sprintf_append(out, "\tModule [%s] Pointer <%p>", it -> first.c_str(), (void *) ((it -> second) -> pqi)); rs_sprintf_append(out, "\tModule [%s] Pointer <%p>", it -> first.toStdString().c_str(), (void *) ((it -> second) -> pqi));
} }
pqioutput(PQL_DEBUG_BASIC, pqihandlerzone, out); pqioutput(PQL_DEBUG_BASIC, pqihandlerzone, out);
@ -150,7 +150,7 @@ bool pqihandler::AddSearchModule(SearchModule *mod)
return false; return false;
} }
if (mod->peerid == "") if (mod->peerid.isNull())
{ {
// ERROR! // ERROR!
pqioutput(PQL_ALERT, pqihandlerzone, "ERROR peerid == NULL"); pqioutput(PQL_ALERT, pqihandlerzone, "ERROR peerid == NULL");
@ -261,7 +261,7 @@ int pqihandler::locked_HandleRsItem(RsItem *item, int allowglobal,uint32_t& comp
// check security... is output allowed. // check security... is output allowed.
if(0 < secpolicy_check((it -> second) -> sp, 0, PQI_OUTGOING)) if(0 < secpolicy_check((it -> second) -> sp, 0, PQI_OUTGOING))
{ {
std::string out = "pqihandler::HandleRsItem() sending to chan: " + it -> first; std::string out = "pqihandler::HandleRsItem() sending to chan: " + it -> first.toStdString();
pqioutput(PQL_DEBUG_BASIC, pqihandlerzone, out); pqioutput(PQL_DEBUG_BASIC, pqihandlerzone, out);
#ifdef DEBUG_TICK #ifdef DEBUG_TICK
std::cerr << out << std::endl; std::cerr << out << std::endl;

2
libretroshare/src/pqi/pqiloopback.cc
View file

@ -30,7 +30,7 @@
#define LOOPBACK_DEBUG 1 #define LOOPBACK_DEBUG 1
***/ ***/
pqiloopback::pqiloopback(std::string id) pqiloopback::pqiloopback(const RsPeerId& id)
:PQInterface(id) :PQInterface(id)
{ {
setMaxRate(true, 0); setMaxRate(true, 0);

2
libretroshare/src/pqi/pqiperson.h
View file

@ -82,7 +82,7 @@ virtual bool connect_additional_address(uint32_t type, const struct sockaddr_st
virtual int getConnectAddress(struct sockaddr_storage &raddr){ return ni->getConnectAddress(raddr); } virtual int getConnectAddress(struct sockaddr_storage &raddr){ return ni->getConnectAddress(raddr); }
// get the contact from the net side! // get the contact from the net side!
virtual std::string PeerId() virtual const RsPeerId& PeerId()
{ {
if (ni) if (ni)
{ {

2
libretroshare/src/pqi/pqiqosstreamer.h
View file

@ -31,7 +31,7 @@
class pqiQoSstreamer: public pqithreadstreamer, public pqiQoS class pqiQoSstreamer: public pqithreadstreamer, public pqiQoS
{ {
public: public:
pqiQoSstreamer(PQInterface *parent, RsSerialiser *rss, std::string peerid, BinInterface *bio_in, int bio_flagsin); pqiQoSstreamer(PQInterface *parent, RsSerialiser *rss, const RsPeerId& peerid, BinInterface *bio_in, int bio_flagsin);
static const uint32_t PQI_QOS_STREAMER_MAX_LEVELS = 10 ; static const uint32_t PQI_QOS_STREAMER_MAX_LEVELS = 10 ;
static const float PQI_QOS_STREAMER_ALPHA = 2.0 ; static const float PQI_QOS_STREAMER_ALPHA = 2.0 ;

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

@ -79,7 +79,7 @@ template<uint32_t ID_SIZE_IN_BYTES,uint32_t UNIQUE_IDENTIFIER> class t_RsGeneric
inline bool isNull() const inline bool isNull() const
{ {
for(int i=0;i<SIZE_IN_BYTES;++i) for(uint32_t i=0;i<SIZE_IN_BYTES;++i)
if(bytes[i] != 0) if(bytes[i] != 0)
return false ; return false ;
return true ; return true ;

32
libretroshare/src/serialiser/rsbaseserial.cc
View file

@ -250,6 +250,23 @@ bool setRawSha1(void *data,uint32_t size,uint32_t *offset,const Sha1CheckSum& cs
return true ; return true ;
} }
bool getRawPGPId(void *data,uint32_t size,uint32_t *offset,PGPIdType& cs)
{
uint32_t len = PGPIdType::SIZE_IN_BYTES ; // SSL id type
/* check there is space for string */
if (size < *offset + len)
{
std::cerr << "getRawPGPId() not enough size" << std::endl;
return false;
}
bool ok = true ;
cs = PGPIdType(&((uint8_t*)data)[*offset]) ;
*offset += len ;
return ok ;
}
bool getRawSSLId(void *data,uint32_t size,uint32_t *offset,SSLIdType& cs) bool getRawSSLId(void *data,uint32_t size,uint32_t *offset,SSLIdType& cs)
{ {
uint32_t len = 16 ; // SSL id type uint32_t len = 16 ; // SSL id type
@ -267,6 +284,21 @@ bool getRawSSLId(void *data,uint32_t size,uint32_t *offset,SSLIdType& cs)
return ok ; return ok ;
} }
bool setRawPGPId(void *data,uint32_t size,uint32_t *offset,const PGPIdType& cs)
{
uint32_t len = PGPIdType::SIZE_IN_BYTES ; // SHA1 length in bytes
if (size < *offset + len)
{
std::cerr << "setRawPGPId() Not enough size" << std::endl;
return false;
}
memcpy((void *) &(((uint8_t *) data)[*offset]), cs.toByteArray(), PGPIdType::SIZE_IN_BYTES);
*offset += PGPIdType::SIZE_IN_BYTES ;
return true ;
}
bool setRawSSLId(void *data,uint32_t size,uint32_t *offset,const SSLIdType& cs) bool setRawSSLId(void *data,uint32_t size,uint32_t *offset,const SSLIdType& cs)
{ {
uint32_t len = 16 ; // SHA1 length in bytes uint32_t len = 16 ; // SHA1 length in bytes

3
libretroshare/src/serialiser/rsbaseserial.h
View file

@ -72,6 +72,9 @@ bool setRawSha1(void *data, uint32_t size, uint32_t *offset, const Sha1CheckSum&
bool setRawSSLId(void *data, uint32_t size, uint32_t *offset, const SSLIdType& inStr); bool setRawSSLId(void *data, uint32_t size, uint32_t *offset, const SSLIdType& inStr);
bool getRawSSLId(void *data, uint32_t size, uint32_t *offset, SSLIdType& outStr); bool getRawSSLId(void *data, uint32_t size, uint32_t *offset, SSLIdType& outStr);
bool setRawPGPId(void *data, uint32_t size, uint32_t *offset, const PGPIdType& inStr);
bool getRawPGPId(void *data, uint32_t size, uint32_t *offset, PGPIdType& outStr);
bool setRawPGPFingerprint(void *data, uint32_t size, uint32_t *offset, const PGPFingerprintType& inStr); bool setRawPGPFingerprint(void *data, uint32_t size, uint32_t *offset, const PGPFingerprintType& inStr);
bool getRawPGPFingerprint(void *data, uint32_t size, uint32_t *offset, PGPFingerprintType& outStr); bool getRawPGPFingerprint(void *data, uint32_t size, uint32_t *offset, PGPFingerprintType& outStr);

8
libretroshare/src/serialiser/rsconfigitems.cc
View file

@ -1342,7 +1342,7 @@ std::ostream& RsPeerServicePermissionItem::print(std::ostream &out, uint16_t ind
for(uint32_t i=0;i<pgp_ids.size();++i) for(uint32_t i=0;i<pgp_ids.size();++i)
{ {
printIndent(out, int_Indent); printIndent(out, int_Indent);
out << "pgp id: " << pgp_ids[i] << ": " << service_flags[i].toUInt32() << std::endl; out << "pgp id: " << pgp_ids[i].toStdString() << ": " << service_flags[i].toUInt32() << std::endl;
} }
printRsItemEnd(out, "RsPeerServicePermissionItem", indent); printRsItemEnd(out, "RsPeerServicePermissionItem", indent);
return out; return out;
@ -1355,7 +1355,7 @@ uint32_t RsPeerConfigSerialiser::sizePermissions(RsPeerServicePermissionItem *i)
for(uint32_t j=0;j<i->pgp_ids.size();++j) for(uint32_t j=0;j<i->pgp_ids.size();++j)
{ {
s += GetTlvStringSize(i->pgp_ids[j]) ; s += PGPIdType::SIZE_IN_BYTES ;//GetTlvStringSize(i->pgp_ids[j]) ;
s += 4; /* flag */ s += 4; /* flag */
} }
@ -1391,7 +1391,7 @@ bool RsPeerConfigSerialiser::serialisePermissions(RsPeerServicePermissionItem *i
for(uint32_t i=0;i<item->pgp_ids.size();++i) for(uint32_t i=0;i<item->pgp_ids.size();++i)
{ {
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_KEY, item->pgp_ids[i]); ok &= setRawPGPId(data, tlvsize, &offset, item->pgp_ids[i]);
ok &= setRawUInt32(data, tlvsize, &offset, item->service_flags[i].toUInt32()); ok &= setRawUInt32(data, tlvsize, &offset, item->service_flags[i].toUInt32());
} }
@ -1446,7 +1446,7 @@ RsPeerServicePermissionItem *RsPeerConfigSerialiser::deserialisePermissions(void
for(uint32_t i=0;i<s;++i) for(uint32_t i=0;i<s;++i)
{ {
uint32_t flags ; uint32_t flags ;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_KEY, item->pgp_ids[i]); ok &= getRawPGPId(data, rssize, &offset, item->pgp_ids[i]);
ok &= getRawUInt32(data, rssize, &offset, &flags); ok &= getRawUInt32(data, rssize, &offset, &flags);
item->service_flags[i] = ServicePermissionFlags(flags) ; item->service_flags[i] = ServicePermissionFlags(flags) ;

4
libretroshare/src/serialiser/rsconfigitems.h
View file

@ -109,7 +109,7 @@ class RsPeerServicePermissionItem : public RsItem
std::ostream &print(std::ostream &out, uint16_t indent = 0); std::ostream &print(std::ostream &out, uint16_t indent = 0);
/* Mandatory */ /* Mandatory */
std::vector<std::string> pgp_ids ; std::vector<PGPIdType> pgp_ids ;
std::vector<ServicePermissionFlags> service_flags ; std::vector<ServicePermissionFlags> service_flags ;
}; };
class RsPeerGroupItem : public RsItem class RsPeerGroupItem : public RsItem
@ -131,7 +131,7 @@ public:
std::string name; std::string name;
uint32_t flag; uint32_t flag;
std::list<std::string> peerIds; std::list<RsPeerId> peerIds;
}; };