Add a checker which prevents of adding your own gpg_id.

Add an inactive friends list based on last seen Unix timestamp.
Add a method of removing a specific peer based on peer_id.

As fas as I know, the same pgp_id will discorvery themself and add online subnodes automaticlly even you remove one of them their just keep coming back, but if you accidently add your own peer_id on the WebUI, the peer list will show two identical PGP names and its subnodes, untill the retroshare gets restarted.

And this modification don't add the same peer_id as long as it belongs to your current node, it doesn't mean you can't add your new nodes with the same pgp_id but different peer_id.

Honor the Allman indent style

libresapi/src/api/PeersHandler.cpp

@@ -32,6 +32,11 @@
 #include "Operators.h"
 #include "ApiTypes.h"
 
+//#include "util/rsdebug.h"
+
+//static struct RsLog::logInfo peersHandlerInfo = {RsLog::Default, "peersHandler"};
+//#define peerhandlerzone &peersHandlerInfo
+
 namespace resource_api
 {
 
@@ -70,12 +75,13 @@ void peerDetailsToStream(StreamBase& stream, RsPeerDetails& details)
 	}
 
 	stream
-        << makeKeyValueReference("peer_id", details.id)
+		<< makeKeyValueReference("pgp_id"        , details.gpg_id)
-        << makeKeyValueReference("name", details.name)
+		<< makeKeyValueReference("peer_id"       , details.id)
-        << makeKeyValueReference("location", details.location)
+		<< makeKeyValueReference("name"          , details.name)
-        << makeKeyValueReference("pgp_id", details.gpg_id)
+		<< makeKeyValueReference("location"      , details.location)
-        << makeKeyValueReference("isHiddenNode", details.isHiddenNode)
+		<< makeKeyValueReference("is_hidden_node", details.isHiddenNode)
-        << makeKeyValueReference("nodeType",  nodeType_string );
+		<< makeKeyValueReference("nodeType"      , nodeType_string )
+		<< makeKeyValueReference("last_contact"  , details.lastConnect );
 
 	if(details.state & RS_PEER_STATE_CONNECTED)
 	{
@@ -252,6 +258,8 @@ PeersHandler::PeersHandler(StateTokenServer* sts, RsNotify* notify, RsPeers *pee
 	addResourceHandler("get_node_options", this, &PeersHandler::handleGetNodeOptions);
 	addResourceHandler("set_node_options", this, &PeersHandler::handleSetNodeOptions);
 	addResourceHandler("examine_cert", this, &PeersHandler::handleExamineCert);
+	addResourceHandler("remove_node", this, &PeersHandler::handleRemoveNode);
+	addResourceHandler("get_inactive_users", this, &PeersHandler::handleGetInactiveUsers);
 
 }
 
@@ -504,6 +512,7 @@ void PeersHandler::handleWildcard(Request &req, Response &resp)
 				locationStream.getStreamToMember();
 
 				int bestPeerState = 0;
+				uint32_t lastConnect = 0;
 				unsigned int bestRSState = 0;
 				std::string bestCustomStateString;
 
@@ -518,6 +527,9 @@ void PeersHandler::handleWildcard(Request &req, Response &resp)
 						stream << makeKeyValueReference("unread_msgs", unread);
 						peerInfoToStream(stream,*vit, mRsPeers, grpInfo, have_avatar(mRsMsgs, vit->id));
 						
+						// Get latest contact timestamp
+						if(vit->lastConnect > lastConnect)
+							lastConnect = vit->lastConnect;
 
 						/* Custom state string */
 						std::string customStateString;
@@ -596,6 +608,7 @@ void PeersHandler::handleWildcard(Request &req, Response &resp)
 					state_string = "undefined";
 
 				itemStream << makeKeyValue("state_string", state_string);
+				itemStream << makeKeyValue("last_contact", lastConnect);
 			}
 			resp.mStateToken = getCurrentStateToken();
 		}
@@ -624,32 +637,132 @@ void PeersHandler::handleWildcard(Request &req, Response &resp)
 			{
 				flags = RS_NODE_PERM_DEFAULT;
 			}
-            RsPeerId peer_id;
+			//RsPeerId peer_id;
-            RsPgpId pgp_id;
+			//RsPgpId pgp_id;
-			std::string cleanCert;
+			//std::string cleanCert;
-			int error_code;
+			uint32_t error_code;
 			std::string error_string;
+			RsPeerDetails peerDetails;
+			//std::string debug_string = " ";
+			RsPgpId own_pgp = mRsPeers->getGPGOwnId();
+			RsPeerId ownpeer_id = mRsPeers->getOwnId();
+			do
+			{
 				
-			if (mRsPeers->cleanCertificate(cert_string, cleanCert, error_code))
+				if (!cert_string.empty())
 				{
-				if(mRsPeers->loadCertificateFromString(cert_string, peer_id, pgp_id, error_string)
+					RsPgpId pgp_id ;
-				        && mRsPeers->addFriend(peer_id, pgp_id, flags))
+					RsPeerId ssl_id ;
+					std::string error_string ;
+
+					if(!mRsPeers->loadCertificateFromString(cert_string,ssl_id,pgp_id,error_string))
 					{
-					ok = true;
+						std::cerr << "handleWildcard::loadCertificateFromString(): cannot load that certificate. " ;
-					resp.mDataStream << makeKeyValueReference("pgp_id", pgp_id);
+						std::cerr << error_string << std::endl;
-					resp.mDataStream << makeKeyValueReference("peer_id", peer_id);
+						resp.mDebug << "cannot load that certificate " << std::endl;
-				}
-				else
-				{
-					resp.mDebug << "Error: failed to add peer" << std::endl;
 						resp.mDebug << error_string << std::endl;
+						break ;
 					}
 				}
+				
+				std::cerr << "handleWildcard addPeer: loadDetailsFromStringCert" << std::endl;
+				
+				if(!mRsPeers->loadDetailsFromStringCert(cert_string, peerDetails, error_code))
+				{
+					resp.mDebug << "Error: failed to add peer can not get peerDetails" << std::endl;
+					resp.mDebug << error_code << std::endl;
+					break;
+				}            
+				
+				std::cerr << "handleWildcard addPeer: peerDetails.gpg_id" << std::endl;
+				 
+				if(peerDetails.gpg_id.isNull())
+				{
+					resp.mDebug << "Error: failed to add peer gpg_id.isNull" << std::endl;
+					resp.mDebug << error_string << std::endl;
+					break;
+				}
+				
+				if(peerDetails.gpg_id == own_pgp)
+				{
+					if(peerDetails.id == ownpeer_id)
+					{
+						std::cerr << "handleWildcard addPeer: is own peer_id, ignore" << std::endl;
+						resp.mDebug << "Error: failed to add peer_id, because its your own peer_id" << std::endl;
+						resp.mDebug << error_string << std::endl;
+						break;
+					}
+					
+					std::cerr << "handleWildcard addPeer: is own pgp_id, update only" << std::endl;
+					
+				}
 				else
 				{
-				resp.mDebug << "Error: failed to add peer" << std::endl;
+				
-				resp.mDebug << error_code << std::endl;
+					if(!mRsPeers->addFriend(peerDetails.id, peerDetails.gpg_id, flags))
+					{
+						resp.mDebug << "Error: failed to addFriend" << std::endl;
+						resp.mDebug << error_string << std::endl;
+						break;
 					}
+					
+					std::cerr << "handleWildcard addPeer: addFriend ok " << peerDetails.gpg_id << std::endl;
+					
+			   }
+				
+				ok = true;
+				
+				// Retrun node details to response, after succes of adding peers
+				peerDetailsToStream(resp.mDataStream, peerDetails);
+				
+				std::cerr << "handleWildcard addPeer: peerDetailsToStream" << std::endl;
+				
+				if (!peerDetails.location.empty()) 
+				{
+					std::cerr << "handleWildcard addPeer: setting peer node." << std::endl;
+					mRsPeers->setLocation(peerDetails.id, peerDetails.location);
+				}
+				
+				// Update new address even the peer already existed.
+				if (peerDetails.isHiddenNode)
+				{
+					std::cerr << "handleWildcard addPeer: setting hidden node.";
+					std::cerr << peerDetails.hiddenNodeAddress;
+					std::cerr << " Port: " << peerDetails.hiddenNodePort << std::endl;
+					mRsPeers->setHiddenNode(peerDetails.id, peerDetails.hiddenNodeAddress, peerDetails.hiddenNodePort);
+				}
+				else
+				{
+					//let's check if there is ip adresses in the certificate.
+					if (!peerDetails.extAddr.empty() && peerDetails.extPort) 
+					{
+						std::cerr << "handleWildcard addPeer: setting ip ext address." ;
+						std::cerr << peerDetails.extAddr;
+						std::cerr << " Port: " << peerDetails.extPort;
+						std::cerr << std::endl;
+						mRsPeers->setExtAddress(peerDetails.id, peerDetails.extAddr, peerDetails.extPort);
+					}
+					if (!peerDetails.localAddr.empty() && peerDetails.localPort) 
+					{
+						std::cerr << "handleWildcard addPeer: setting ip local address." ;
+						std::cerr << peerDetails.localAddr;
+						std::cerr << " Port: " << peerDetails.localPort << std::endl;
+						mRsPeers->setLocalAddress(peerDetails.id, peerDetails.localAddr, peerDetails.localPort);
+					}
+					if (!peerDetails.dyndns.empty()) 
+					{
+					   
+						std::cerr << "handleWildcard addPeer: setting DynDNS." ;
+						std::cerr << peerDetails.dyndns << std::endl;
+						mRsPeers->setDynDNS(peerDetails.id, peerDetails.dyndns);
+					}
+				}
+				
+				// std::cerr << debug_string << std::endl;
+				// resp.mDebug << debug_string  << std::endl;
+				// rslog(RSL_WARNING, peerhandlerzone, debug_string );
+			
+			}while(0);
 		}
 	}
 	if(ok)
@@ -692,6 +805,118 @@ void PeersHandler::handleExamineCert(Request &req, Response &resp)
 	}
 }
 
+/**
+ *  \brief Remove specific location or user
+ *  
+ *  \param [in] req request from user either peer_id or gpg_id is needed.
+ *  \param [in] resp response to user
+ *  \return 
+ *  
+ *  \details 
+ */
+void PeersHandler::handleRemoveNode(Request &req, Response &resp)
+{
+	std::string ssl_peer_id;
+	std::string gpg_id;
+	req.mStream << makeKeyValueReference("peer_id", ssl_peer_id);
+	req.mStream << makeKeyValueReference("gpg_id", gpg_id);
+	RsPeerId peerId(ssl_peer_id);
+	RsPgpId gpgId(gpg_id);
+	
+	if(!gpgId.isNull())
+	{
+		mRsPeers->removeFriend(gpgId);
+		resp.mDataStream << makeKeyValue("gpg_id", gpg_id);
+		resp.setOk(); 
+	}
+	else if(!peerId.isNull())
+	{
+		mRsPeers->removeFriendLocation(peerId);
+		resp.mDataStream << makeKeyValue("peer_id", ssl_peer_id);
+		resp.setOk();        
+	}
+	else
+	{
+		resp.setFail("handleRemoveNode Invalid peer_id or gpg_id");
+	}
+}
+
+/**
+ *  \brief Retrieve inactive user list before specific UNIX time
+ *  
+ *  \param [in] req request from user, datatime in UNIX timestamp.
+ *  \param [in] resp response to request
+ *  \return a pgp_id list.
+ *  
+ *  \details Combine this with handleRemoveNode, 
+ *  batch remove inactive users are possible and convenient.
+ */
+void PeersHandler::handleGetInactiveUsers(Request &req, Response &resp)
+{
+	std::string datetime;
+	req.mStream << makeKeyValueReference("datetime", datetime);
+	
+	uint32_t before = strtoul(datetime.c_str(), NULL, 10);
+	
+	if(datetime.empty())
+	{
+		std::cerr << "PeersHandler:datetime is empty" << std::endl;
+		before = time(NULL);
+	}
+	
+  
+	// list all peers
+	std::list<RsPeerId> peers;
+	mRsPeers->getFriendList(peers);
+	
+	// Make pair of gpg_id and last connect time
+	std::map<RsPgpId, uint32_t> mapRsPgpId;
+	
+	// get all peers' infomations
+	for(std::list<RsPeerId>::iterator lt = peers.begin(); lt != peers.end(); ++lt)
+	{
+		RsPeerDetails details;
+		mRsPeers->getPeerDetails(*lt, details);
+		// Search for exist pgp_id, update the last connect time
+		if(mapRsPgpId.find(details.gpg_id) != mapRsPgpId.end())
+		{
+			if(mapRsPgpId[details.gpg_id] < details.lastConnect)
+				mapRsPgpId[details.gpg_id] = details.lastConnect;
+		}
+		else
+		{
+			mapRsPgpId.insert(std::make_pair(details.gpg_id, details.lastConnect));
+		}
+		
+	}
+	
+	// mark response as list, in case it is empty
+	resp.mDataStream.getStreamToMember();
+	
+	std::map<RsPgpId, uint32_t>::iterator lit;
+	for( lit = mapRsPgpId.begin(); lit != mapRsPgpId.end(); ++lit)
+	{
+		
+		if (lit->second < before)
+		{
+			
+			std::cerr << "YES Adding OLD: " <<  mRsPeers->getGPGName(lit->first);
+			std::cerr << "last_contact: " << lit->second <<std::endl;
+			
+			StreamBase& itemStream = resp.mDataStream.getStreamToMember();
+			itemStream << makeKeyValue("pgp_id", lit->first.toStdString());
+			itemStream << makeKeyValue("name", mRsPeers->getGPGName(lit->first));
+			itemStream << makeKeyValue("last_contact", lit->second);
+
+		}
+
+	}
+	
+	resp.setOk();
+	
+}
+
+
 void PeersHandler::handleGetNetworkOptions(Request& /*req*/, Response& resp)
 {
 	RsPeerDetails detail;
@@ -864,7 +1089,7 @@ void PeersHandler::handleSetNetworkOptions(Request& req, Response& resp)
 
 	bool checkIP;
 	req.mStream << makeKeyValueReference("check_ip", checkIP);
-	rsPeers->allowServerIPDetermination(checkIP) ;
+	mRsPeers->allowServerIPDetermination(checkIP) ;
 
 	// Tor
 	std::string toraddr;
@@ -1109,7 +1334,7 @@ void PeersHandler::handleSetNodeOptions(Request& req, Response& resp)
 	else
 	{
 		if(detail.hiddenNodeAddress != local_address || detail.hiddenNodePort != local_port)
-			rsPeers->setHiddenNode(peerId, local_address, local_port);
+			mRsPeers->setHiddenNode(peerId, local_address, local_port);
 	}
 
 	resp.setOk();

libresapi/src/api/PeersHandler.h

@@ -73,6 +73,8 @@ private:
 	void handleGetNodeOptions(Request& req, Response& resp);
 	void handleSetNodeOptions(Request& req, Response& resp);
 	
+	void handleRemoveNode(Request &req, Response &resp);
+	void handleGetInactiveUsers(Request &req, Response &resp);
 	// a helper which ensures proper mutex locking
 	StateToken getCurrentStateToken();