Merge pull request #47 from RetroShare/master

update to master

libretroshare/src/grouter/grouteritems.cc

@@ -108,7 +108,7 @@ void RsGRouterGenericDataItem::serial_process(RsGenericSerializer::SerializeJob
 
     RsTypeSerializer::serial_process<RsTlvItem>(j,ctx,signature,"signature") ;
     RsTypeSerializer::serial_process<uint32_t>(j,ctx,duplication_factor,"duplication_factor") ;
-    RsTypeSerializer::serial_process<uint32_t>(j,ctx,flags,"flags") ;
+	RS_SERIAL_PROCESS(flags);
 
     if(j == RsGenericSerializer::DESERIALIZE) // make sure the duplication factor is not altered by friends. In the worst case, the item will duplicate a bit more.
     {
@@ -128,7 +128,7 @@ void RsGRouterGenericDataItem::serial_process(RsGenericSerializer::SerializeJob
 void RsGRouterSignedReceiptItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
 {
     RsTypeSerializer::serial_process<uint64_t> (j,ctx,routing_id,"routing_id") ;
-    RsTypeSerializer::serial_process<uint32_t> (j,ctx,flags,"flags") ;
+    RS_SERIAL_PROCESS(flags);
     RsTypeSerializer::serial_process           (j,ctx,destination_key,"destination_key") ;
     RsTypeSerializer::serial_process<uint32_t> (j,ctx,service_id,"service_id") ;
     RsTypeSerializer::serial_process           (j,ctx,data_hash,"data_hash") ;
@@ -269,3 +269,4 @@ RsGRouterSignedReceiptItem *RsGRouterSignedReceiptItem::duplicate() const
     return item ;
 }
 
+RsGRouterAbstractMsgItem::~RsGRouterAbstractMsgItem() = default;

libretroshare/src/grouter/grouteritems.h

@@ -27,7 +27,7 @@
 #include "serialiser/rstlvkeys.h"
 #include "rsitems/rsserviceids.h"
 #include "retroshare/rstypes.h"
-
+#include "retroshare/rsflags.h"
 #include "retroshare/rsgrouter.h"
 #include "groutermatrix.h"
 
@@ -83,40 +83,59 @@ class RsGRouterNonCopyableObject
 // and routing ID. Sub-items are responsible for providing the serialised data to be signed for
 // both signing and checking.
 
-class RsGRouterAbstractMsgItem: public RsGRouterItem
+enum class RsGRouterItemFlags : uint32_t
 {
-public:
+	NONE               = 0x0,
-    explicit RsGRouterAbstractMsgItem(uint8_t pkt_subtype) : RsGRouterItem(pkt_subtype), flags(0) {}
+	ENCRYPTED          = 0x1,
-    virtual ~RsGRouterAbstractMsgItem() {}
+	SERVICE_UNKNOWN    = 0x2
+};
+RS_REGISTER_ENUM_FLAGS_TYPE(RsGRouterItemFlags)
+
+struct RsGRouterAbstractMsgItem: RsGRouterItem
+{
+    explicit RsGRouterAbstractMsgItem(uint8_t pkt_subtype):
+        RsGRouterItem(pkt_subtype), flags(RsGRouterItemFlags::NONE) {}
 
     GRouterMsgPropagationId routing_id ;
     GRouterKeyId destination_key ;
     GRouterServiceId service_id ;
     RsTlvKeySignature signature ;		// signs mid+destination_key+state
-	uint32_t flags ; 					// packet was delivered, not delivered, bounced, etc
+
+	/// packet was delivered, not delivered, bounced, etc
+	RsGRouterItemFlags flags;
+
+	~RsGRouterAbstractMsgItem();
 };
 
-class RsGRouterGenericDataItem: public RsGRouterAbstractMsgItem, public RsGRouterNonCopyableObject
+class RsGRouterGenericDataItem:
+        public RsGRouterAbstractMsgItem, public  RsGRouterNonCopyableObject
 {
-    public:
+public:
-        RsGRouterGenericDataItem() : RsGRouterAbstractMsgItem(RS_PKT_SUBTYPE_GROUTER_DATA), data_size(0), data_bytes(NULL), duplication_factor(0) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; }
+	RsGRouterGenericDataItem():
-        virtual ~RsGRouterGenericDataItem() { clear() ; }
+	    RsGRouterAbstractMsgItem(RS_PKT_SUBTYPE_GROUTER_DATA),
+	    data_size(0), data_bytes(nullptr), duplication_factor(0)
+	{ setPriorityLevel(QOS_PRIORITY_RS_GROUTER); }
 
+	virtual ~RsGRouterGenericDataItem() { clear(); }
 	virtual void clear() 
 	{ 
 		free(data_bytes); 
-            data_bytes=NULL;
+		data_bytes = nullptr;
 	}
 
-		virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx);
+	virtual void serial_process(
+	        RsGenericSerializer::SerializeJob j,
+	        RsGenericSerializer::SerializeContext& ctx );
 
-        RsGRouterGenericDataItem *duplicate() const ;
+	RsGRouterGenericDataItem *duplicate() const;
 
-        // packet data
+	/// packet data
-        //
+	uint32_t data_size;
-        uint32_t data_size ;
+	uint8_t* data_bytes;
-        uint8_t *data_bytes;
+
-        uint32_t duplication_factor ;	// number of duplicates allowed. Should be capped at each de-serialise operation!
+	/** number of duplicates allowed. Should be capped at each de-serialise
+	 * operation! */
+	uint32_t duplication_factor;
 };
 
 class RsGRouterSignedReceiptItem: public RsGRouterAbstractMsgItem

libretroshare/src/grouter/p3grouter.cc

@@ -178,7 +178,7 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include <unistd.h>
-#include <math.h>
+#include <cmath>
 
 #include "util/rsrandom.h"
 #include "util/rsprint.h"
@@ -188,7 +188,7 @@
 #include "turtle/p3turtle.h"
 #include "gxs/rsgixs.h"
 #include "retroshare/rspeers.h"
-
+#include "util/cxx17retrocompat.h"
 #include "p3grouter.h"
 #include "grouteritems.h"
 #include "groutertypes.h"
@@ -200,25 +200,18 @@
 
 const std::string p3GRouter::SERVICE_INFO_APP_NAME = "Global Router" ;
 
-p3GRouter::p3GRouter(p3ServiceControl *sc, RsGixs *is)
+p3GRouter::p3GRouter(p3ServiceControl *sc, RsGixs *is) :
-    : p3Service(), p3Config(), mServiceControl(sc), mTurtle(NULL), mGixs(is), grMtx("GRouter")
+    p3Service(), p3Config(), mServiceControl(sc), mTurtle(nullptr), mGixs(is),
-{
+    grMtx("GRouter"), _changed(false), _debug_enabled(true),
-	addSerialType(new RsGRouterSerialiser()) ;
+    _last_autowash_time(0), _last_matrix_update_time(0),
-
+    _last_debug_output_time(0),  _last_config_changed(0),
-	_last_autowash_time = 0 ;
+    _random_salt(RsRandom::random_u64()),
-	_last_debug_output_time = 0 ;
+    mMissingKeyQueueMtx("GRouterMissingKeyQueue")
-	_last_config_changed = 0 ;
+{ addSerialType(new RsGRouterSerialiser()); }
-	_last_matrix_update_time = 0 ;
-	_debug_enabled = true ;
-
-	_random_salt = RSRandom::random_u64() ;
-
-	_changed = false ;
-}
 
 int p3GRouter::tick()
 {
-    rstime_t now = time(NULL) ;
+	rstime_t now = time(nullptr);
 
     // Sort incoming service data
     //
@@ -242,6 +235,41 @@ int p3GRouter::tick()
     //
     handleTunnels() ;
 
+	/* Handle items in mMissingKeyQueue */
+	if(now > mMissingKeyQueueCheckLastCheck + mMissingKeyQueueCheckEvery)
+	{
+		mMissingKeyQueueCheckLastCheck = now;
+
+		RS_STACK_MUTEX(mMissingKeyQueueMtx);
+		for(auto it = mMissingKeyQueue.begin(); it != mMissingKeyQueue.end();)
+		{
+			const RsGxsId& senderId = it->first->signature.keyId;
+			if(rsIdentity->isKnownId(senderId))
+			{
+				Dbg2() << __PRETTY_FUNCTION__ << " got key: " << senderId
+				       << " for item pending validation, calling item handler"
+				       << std::endl;
+
+				handleIncomingItem(it->first.get());
+				it = mMissingKeyQueue.erase(it);
+			}
+			else
+			{
+				Dbg3() << __PRETTY_FUNCTION__ << " requesting missing key: "
+				       << senderId << " to validate pending item" << std::endl;
+
+				/* At this point the network status may have varied a lot since
+				 * we received the item, so we don't even know if the peer who
+				 * forwarded the item is still online, moreover the fact that
+				 * after specific request we haven't got the key yet suggests it
+				 * is not a good route toward the key, so request it to all
+				 * available peers */
+				rsIdentity->requestIdentity(senderId);
+				++it;
+			}
+		}
+	}
+
     // Update routing matrix
     //
     if(now > _last_matrix_update_time + RS_GROUTER_MATRIX_UPDATE_PERIOD)
@@ -325,14 +353,12 @@ bool p3GRouter::unregisterKey(const RsGxsId& key_id,const GRouterServiceId& sid)
 
     Sha1CheckSum hash = makeTunnelHash(key_id,sid) ;
 
-    std::map<Sha1CheckSum,GRouterPublishedKeyInfo>::iterator it = _owned_key_ids.find(hash) ;
+	const auto it = _owned_key_ids.find(hash);
-
 	if(it == _owned_key_ids.end())
 	{
-#ifdef GROUTER_DEBUG
+		RsErr() << __PRETTY_FUNCTION__ << " key " << key_id << " not found."
-        std::cerr << "p3GRouter::unregisterKey(): key " << key_id << " not found." << std::endl;
+		        << std::endl;
-#endif
+		return false;
-		return false ;
 	}
 
 #ifdef GROUTER_DEBUG
@@ -479,7 +505,7 @@ void p3GRouter::handleLowLevelTransactionAckItem(RsGRouterTransactionAcknItem *t
 #endif
 }
 
-void p3GRouter::receiveTurtleData(const RsTurtleGenericTunnelItem *gitem, const RsFileHash &/*hash*/, const RsPeerId &virtual_peer_id, RsTurtleGenericTunnelItem::Direction /*direction*/)
+void p3GRouter::receiveTurtleData(const RsTurtleGenericTunnelItem *gitem, const RsFileHash & hash, const RsPeerId &virtual_peer_id, RsTurtleGenericTunnelItem::Direction direction)
 {
 #ifdef GROUTER_DEBUG
     std::cerr << "p3GRouter::receiveTurtleData() " << std::endl;
@@ -1304,7 +1330,7 @@ bool p3GRouter::locked_sendTransactionData(const RsPeerId& pid,const RsGRouterTr
 void p3GRouter::autoWash()
 {
     bool items_deleted = false ;
-    rstime_t now = time(NULL) ;
+	rstime_t now = time(nullptr);
 
     std::map<GRouterMsgPropagationId,std::pair<GRouterClientService *,RsGxsId> > failed_msgs ;
 
@@ -1398,6 +1424,19 @@ void p3GRouter::autoWash()
 			}
 			else
 				++it ;
+
+		/* Cleanup timed out items in mMissingKeyQueue */
+		mMissingKeyQueueMtx.lock();
+		while( mMissingKeyQueue.begin() != mMissingKeyQueue.end() &&
+		       mMissingKeyQueue.front().second <= now )
+		{
+			RsWarn() << __PRETTY_FUNCTION__ << " Deleting timed out item from "
+			         << "unknown RsGxsId: "
+			         << mMissingKeyQueue.front().first->signature.keyId
+			         << std::endl;
+			mMissingKeyQueue.pop_front();
+		}
+		mMissingKeyQueueMtx.unlock();
     }
     // Look into pending items.
 
@@ -1492,27 +1531,31 @@ void p3GRouter::handleIncoming()
         RsGRouterAbstractMsgItem *item = _incoming_items.front() ;
         _incoming_items.pop_front() ;
 
-        RsGRouterGenericDataItem *generic_data_item ;
+        handleIncomingItem(item);
-        RsGRouterSignedReceiptItem *receipt_item ;
-
-        if(NULL != (generic_data_item  = dynamic_cast<RsGRouterGenericDataItem*>(item)))
-            handleIncomingDataItem(generic_data_item) ;
-        else if(NULL != (receipt_item = dynamic_cast<RsGRouterSignedReceiptItem*>(item)))
-            handleIncomingReceiptItem(receipt_item) ;
-        else
-            std::cerr << "Item has unknown type (not data nor signed receipt). Dropping!" << std::endl;
-
         delete item ;
     }
 }
 
-void p3GRouter::handleIncomingReceiptItem(RsGRouterSignedReceiptItem *receipt_item)
+void p3GRouter::handleIncomingItem(const RsGRouterAbstractMsgItem *item)
+{
+        const RsGRouterGenericDataItem *generic_data_item ;
+        const RsGRouterSignedReceiptItem *receipt_item ;
+
+        if(NULL != (generic_data_item  = dynamic_cast<const RsGRouterGenericDataItem*>(item)))
+            handleIncomingDataItem(generic_data_item) ;
+        else if(NULL != (receipt_item = dynamic_cast<const RsGRouterSignedReceiptItem*>(item)))
+            handleIncomingReceiptItem(receipt_item) ;
+        else
+            std::cerr << "Item has unknown type (not data nor signed receipt). Dropping!" << std::endl;
+}
+
+void p3GRouter::handleIncomingReceiptItem(const RsGRouterSignedReceiptItem *receipt_item)
 {
     bool changed = false ;
 #ifdef GROUTER_DEBUG
     std::cerr << "Handling incoming signed receipt item." << std::endl;
     std::cerr << "Item content:" << std::endl;
-    receipt_item->print(std::cerr,2) ;
+    const_cast<RsGRouterSignedReceiptItem*>(receipt_item)->print(std::cerr,2) ;
 #endif
     RsGxsId signer_id ;
 
@@ -1613,17 +1656,17 @@ void p3GRouter::handleIncomingReceiptItem(RsGRouterSignedReceiptItem *receipt_it
         IndicateConfigChanged() ;
 }
 
-Sha1CheckSum p3GRouter::computeDataItemHash(RsGRouterGenericDataItem *data_item)
+Sha1CheckSum p3GRouter::computeDataItemHash(const RsGRouterGenericDataItem *data_item)
 {
 	RsGRouterSerialiser signature_serializer(RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE | RsGenericSerializer::SERIALIZATION_FLAG_SKIP_HEADER);
 
-    uint32_t signed_data_size = signature_serializer.size(data_item);
+    uint32_t signed_data_size = signature_serializer.size(const_cast<RsGRouterGenericDataItem*>(data_item));
     uint32_t total_size = signed_data_size + data_item->signature.TlvSize() ;
     RsTemporaryMemory mem(total_size) ;
 
     uint32_t offset = 0 ;
     uint32_t tmp_size = total_size ;
-    signature_serializer.serialise(data_item,mem,&tmp_size) ;
+    signature_serializer.serialise(const_cast<RsGRouterGenericDataItem*>(data_item),mem,&tmp_size) ;
     if(tmp_size != signed_data_size)
         std::cerr << "(EE) Some error occured in p3GRouter::computeDataItemHash(). Mismatched offset/data size" << std::endl;
 
@@ -1637,12 +1680,12 @@ Sha1CheckSum p3GRouter::computeDataItemHash(RsGRouterGenericDataItem *data_item)
     return RsDirUtil::sha1sum(mem,total_size) ;
 }
 
-void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
+void p3GRouter::handleIncomingDataItem(const RsGRouterGenericDataItem *data_item)
 {
 #ifdef GROUTER_DEBUG
     std::cerr << "Handling incoming data item. " << std::endl;
     std::cerr << "Item content:" << std::endl;
-    data_item->print(std::cerr,2) ;
+    const_cast<RsGRouterGenericDataItem*>(data_item)->print(std::cerr,2) ;
 #endif
 
     // we find 3 things:
@@ -1654,15 +1697,15 @@ void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
     // Send a receipt?           if     A &&  B
     // Notify client?            if     A &&       !C
     //
-    GRouterClientService *client = NULL ;
+    GRouterClientService *clientService = NULL ;
     GRouterServiceId service_id = data_item->service_id ;
     RsGRouterSignedReceiptItem *receipt_item = NULL ;
 
     Sha1CheckSum item_hash = computeDataItemHash(data_item) ;
 
     bool item_is_already_known = false ;
-    bool item_is_for_us = false ;
     bool cache_has_changed = false ;
+	bool item_is_for_us = _owned_key_ids.find( makeTunnelHash(data_item->destination_key,service_id) ) != _owned_key_ids.end() ;
 
     // A - Find client and service ID from destination key.
 #ifdef GROUTER_DEBUG
@@ -1671,23 +1714,12 @@ void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
     {
         RS_STACK_MUTEX(grMtx) ;
 
-        std::map<GRouterServiceId,GRouterClientService*>::const_iterator its = _registered_services.find(service_id) ;
-
-        if(its == _registered_services.end())
-        {
-            std::cerr << "    ERROR: client id " << service_id << " not registered. Consistency error." << std::endl;
-            return ;
-        }
-        client = its->second ;
-
         // also check wether this item is for us or not
 
-        item_is_for_us = _owned_key_ids.find( makeTunnelHash(data_item->destination_key,service_id) ) != _owned_key_ids.end() ;
-
 #ifdef GROUTER_DEBUG
         std::cerr << "    item is " << (item_is_for_us?"":"not") << " for us." << std::endl;
 #endif
-        std::map<GRouterMsgPropagationId,GRouterRoutingInfo>::iterator it = _pending_messages.find(data_item->routing_id) ;
+        auto it = _pending_messages.find(data_item->routing_id) ;
 
         if(it != _pending_messages.end())
         {
@@ -1709,26 +1741,56 @@ void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
             std::cerr << "    item is new." << std::endl;
 #endif
     }
+
+    if(!item_is_already_known)
+    {
+		uint32_t error_status ;
+
+        if(!verifySignedDataItem(data_item,RsIdentityUsage::GLOBAL_ROUTER_SIGNATURE_CHECK,error_status))	// we should get proper flags out of this
+        {
+            switch(error_status)
+			{
+			case RsGixs::RS_GIXS_ERROR_KEY_NOT_AVAILABLE:
+			{
+				RS_STACK_MUTEX(mMissingKeyQueueMtx);
+
+				rstime_t timeout = time(nullptr) + mMissingKeyQueueEntryTimeout;
+				RsGxsId authorId = data_item->signature.keyId;
+				mMissingKeyQueue.push_back( std::make_pair(std::unique_ptr<RsGRouterGenericDataItem>(data_item->duplicate()), timeout) );
+
+				/* Do not request the missing key here to the peer which forwarded the item as verifySignedDataItem(...) does it already */
+
+				RsInfo() << __PRETTY_FUNCTION__ << " Received a message from  unknown RsGxsId: " << authorId <<". Cannot verify signature yet, storing in mMissingKeyQueue for later processing. Timeout: " << timeout << std::endl;
+				return;
+			}
+			default:
+				RsWarn() << __PRETTY_FUNCTION__ << " item signature verification FAILED with: " << error_status << ", Dropping!" << std::endl;
+				return;
+			}
+		}
+#ifdef GROUTER_DEBUG
+        else
+            std::cerr << "    verifying item signature: CHECKED!" ;
+#endif
+    }
+
     // At this point, if item is already known, it is guarrantied to be identical to the stored item.
     // If the item is for us, and not already known, check the signature and hash, and generate a signed receipt
 
     if(item_is_for_us && !item_is_already_known)
     {
+        // Check that we actually have a registered service ready to accept this item. If not, drop it.
+
+		{
+			RS_STACK_MUTEX(grMtx) ;
+			auto its = _registered_services.find(service_id) ;
+
+			if(its != _registered_services.end())
+				clientService = its->second ;
+		}
+
 #ifdef GROUTER_DEBUG
         std::cerr << "  step B: item is for us and is new, so make sure it's authentic and create a receipt" << std::endl;
-#endif
-        uint32_t error_status ;
-        
-        if(!verifySignedDataItem(data_item,RsIdentityUsage::GLOBAL_ROUTER_SIGNATURE_CHECK,error_status))	// we should get proper flags out of this
-        {
-            std::cerr << "    verifying item signature: FAILED! Droping that item" ;
-            std::cerr << "    You probably received a message from a person you don't have key." << std::endl;
-            std::cerr << "    Signature key ID: " << data_item->signature.keyId << std::endl;
-        return ;
-        }
-#ifdef GROUTER_DEBUG
-        else
-            std::cerr << "    verifying item signature: CHECKED!" ;
 #endif
         // No we need to send a signed receipt to the sender.
 
@@ -1737,7 +1799,13 @@ void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
         receipt_item->service_id = data_item->service_id ;
         receipt_item->routing_id = data_item->routing_id ;
         receipt_item->destination_key = data_item->signature.keyId ;
-        receipt_item->flags = 0 ;
+        receipt_item->flags = RsGRouterItemFlags::NONE ;
+
+        if(!clientService)
+		{
+            receipt_item->flags = RsGRouterItemFlags::SERVICE_UNKNOWN;
+			RsWarn() << __PRETTY_FUNCTION__ << " got a message from: " << data_item->signature.keyId << " for an unkown service: " << data_item->service_id << " is your RetroShare version updated?" << std::endl;
+		}
 
 #ifdef GROUTER_DEBUG
         std::cerr << "    preparing signed receipt." << std::endl;
@@ -1813,7 +1881,7 @@ void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
 
     // if the item is for us and is not already known, notify the client.
 
-    if(item_is_for_us && !item_is_already_known)
+    if(clientService && !item_is_already_known)
     {
         // compute the hash before decryption.
 
@@ -1835,9 +1903,9 @@ void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
 
         std::cerr << "    notyfying client." << std::endl;
 #endif
-        if(client->acceptDataFromPeer(decrypted_item->signature.keyId)) 
+        if(clientService->acceptDataFromPeer(decrypted_item->signature.keyId))
 	{
-		client->receiveGRouterData(decrypted_item->destination_key,decrypted_item->signature.keyId,service_id,decrypted_item->data_bytes,decrypted_item->data_size);
+		clientService->receiveGRouterData(decrypted_item->destination_key,decrypted_item->signature.keyId,service_id,decrypted_item->data_bytes,decrypted_item->data_size);
                 
 		decrypted_item->data_bytes = NULL ;
 		decrypted_item->data_size = 0 ;
@@ -1871,7 +1939,7 @@ bool p3GRouter::locked_getLocallyRegisteredClientFromServiceId(const GRouterServ
     return true ;
 }
 
-void p3GRouter::addRoutingClue(const GRouterKeyId& id,const RsPeerId& peer_id)
+void p3GRouter::addRoutingClue(const RsGxsId& id, const RsPeerId& peer_id)
 {
     RS_STACK_MUTEX(grMtx) ;
 #ifdef GROUTER_DEBUG
@@ -1890,7 +1958,7 @@ bool p3GRouter::registerClientService(const GRouterServiceId& id,GRouterClientSe
 
 bool p3GRouter::encryptDataItem(RsGRouterGenericDataItem *item,const RsGxsId& destination_key)
 {
-    assert(!(item->flags & RS_GROUTER_DATA_FLAGS_ENCRYPTED)) ;
+	assert(!(item->flags & RsGRouterItemFlags::ENCRYPTED));
 
 #ifdef GROUTER_DEBUG
     std::cerr << "  Encrypting data for key " << destination_key << std::endl;
@@ -1915,7 +1983,7 @@ bool p3GRouter::encryptDataItem(RsGRouterGenericDataItem *item,const RsGxsId& de
     free(item->data_bytes) ;
     item->data_bytes = encrypted_data ;
     item->data_size = encrypted_size ;
-    item->flags |= RS_GROUTER_DATA_FLAGS_ENCRYPTED ;
+	item->flags |= RsGRouterItemFlags::ENCRYPTED;
 
 #ifdef GROUTER_DEBUG
     std::cerr << "  Encrypted size = " << encrypted_size << std::endl;
@@ -1926,7 +1994,7 @@ return true ;
 }
 bool p3GRouter::decryptDataItem(RsGRouterGenericDataItem *item)
 {
-    assert(item->flags & RS_GROUTER_DATA_FLAGS_ENCRYPTED) ;
+	assert(!!(item->flags & RsGRouterItemFlags::ENCRYPTED));
 
 #ifdef GROUTER_DEBUG
     std::cerr << "  decrypting data for key " << item->destination_key << std::endl;
@@ -1952,7 +2020,7 @@ bool p3GRouter::decryptDataItem(RsGRouterGenericDataItem *item)
     free(item->data_bytes) ;
     item->data_bytes = decrypted_data ;
     item->data_size = decrypted_size ;
-    item->flags &= ~RS_GROUTER_DATA_FLAGS_ENCRYPTED ;
+	item->flags &= ~RsGRouterItemFlags::ENCRYPTED;
 
     return true ;
 }
@@ -2010,56 +2078,62 @@ bool p3GRouter::signDataItem(RsGRouterAbstractMsgItem *item,const RsGxsId& signi
         return false ;
     }
 }
-bool p3GRouter::verifySignedDataItem(RsGRouterAbstractMsgItem *item,const RsIdentityUsage::UsageCode& info,uint32_t& error_status)
+bool p3GRouter::verifySignedDataItem(const RsGRouterAbstractMsgItem *item,const RsIdentityUsage::UsageCode& info,uint32_t& error_status)
 {
     try
     {
 		if( rsReputations->overallReputationLevel(item->signature.keyId) ==
 		        RsReputationLevel::LOCALLY_NEGATIVE )
 		{
-            std::cerr << "(WW) received global router message from banned identity " << item->signature.keyId << ". Rejecting the message." << std::endl;
+			RsWarn() << __PRETTY_FUNCTION__ << " received global router "
-            return false ;
+			         << "message from banned identity " << item->signature.keyId
+			         << ". Rejecting the message." << std::endl;
+			return false;
 		}
-        RsGRouterSerialiser signature_serializer(RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE | RsGenericSerializer::SERIALIZATION_FLAG_SKIP_HEADER);
 
-        uint32_t data_size = signature_serializer.size(item) ;
+		RsGRouterSerialiser signature_serializer(
-		RsTemporaryMemory data(data_size) ;
+		            RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE |
+		            RsGenericSerializer::SERIALIZATION_FLAG_SKIP_HEADER );
+
+		uint32_t data_size = signature_serializer.size(const_cast<RsGRouterAbstractMsgItem*>(item));	// the const cast shouldn't be necessary if size() took a const.
+		RsTemporaryMemory data(data_size);
 
 		if(data == NULL)
 			throw std::runtime_error("Cannot allocate data.") ;
 
-		if(!signature_serializer.serialise(item,data,&data_size))
+		if(!signature_serializer.serialise(const_cast<RsGRouterAbstractMsgItem*>(item),data,&data_size))
-			throw std::runtime_error("Cannot serialise signed data.") ;
+			throw std::runtime_error("Cannot serialise signed data.");
 
-        RsIdentityUsage use(RS_SERVICE_TYPE_GROUTER,info) ;
+		RsIdentityUsage use(RS_SERVICE_TYPE_GROUTER,info);
 
-        if(!mGixs->validateData(data,data_size,item->signature,true,use, error_status))
+		if(!mGixs->validateData( data, data_size, item->signature, true, use, error_status ))
 		{
 			switch(error_status)
 			{
 			case RsGixs::RS_GIXS_ERROR_KEY_NOT_AVAILABLE:
 			{
-                			std::list<RsPeerId> peer_ids ;
+				std::list<RsPeerId> peer_ids;
-                            		peer_ids.push_back(item->PeerId()) ;
+				peer_ids.push_back(item->PeerId());
 
-                			std::cerr << "(EE) Key for GXS Id " << item->signature.keyId << " is not available. Cannot verify. Asking key to peer " << item->PeerId() << std::endl;
+				RsWarn() << __PRETTY_FUNCTION__ << " Key for GXS Id " << item->signature.keyId << " is not available. Cannot verify. Asking key to peer " << item->PeerId() << std::endl;
-                                    
+				mGixs->requestKey(item->signature.keyId,peer_ids,use);
-                			mGixs->requestKey(item->signature.keyId,peer_ids,use) ;   // request the key around
 			}
-                                        break ;
+				break;
-                case RsGixs::RS_GIXS_ERROR_SIGNATURE_MISMATCH: std::cerr << "(EE) Signature mismatch. Spoofing/Corrupted/MITM?." << std::endl;
+			case RsGixs::RS_GIXS_ERROR_SIGNATURE_MISMATCH:
-                                        break ;
+				RsWarn() << __PRETTY_FUNCTION__  << " Signature mismatch. " << "Spoofing/Corrupted/MITM?." << std::endl;
-            default:  std::cerr << "(EE) Signature verification failed on GRouter message. Unknown error status: " << error_status << std::endl;
+				break;
-                break ;
+			default:
+				RsErr() << __PRETTY_FUNCTION__ << " Signature verification failed on GRouter message. Unknown error status: " << error_status << std::endl;
+				break;
 			}
 			return false;
 		}
 
-        return true ;
+		return true;
 	}
 	catch(std::exception& e)
 	{
-        std::cerr << "  signature verification failed. Error: " << e.what() << std::endl;
+		RsErr() << __PRETTY_FUNCTION__ << " Failed. Error: " << e.what() << std::endl;
         return false ;
     }
 }
@@ -2093,7 +2167,7 @@ bool p3GRouter::cancel(GRouterMsgPropagationId mid)
     return true ;
 }
 
-bool p3GRouter::sendData(const RsGxsId& destination,const GRouterServiceId& client_id,const uint8_t *data, uint32_t data_size,const RsGxsId& signing_id, GRouterMsgPropagationId &propagation_id)
+bool p3GRouter::sendData( const RsGxsId& destination, const GRouterServiceId& client_id, const uint8_t* data, uint32_t data_size, const RsGxsId& signing_id, GRouterMsgPropagationId&propagation_id )
 {
 //    std::cerr << "GRouter currently disabled." << std::endl;
 //    return false;
@@ -2127,7 +2201,7 @@ bool p3GRouter::sendData(const RsGxsId& destination,const GRouterServiceId& clie
     data_item->duplication_factor = GROUTER_MAX_DUPLICATION_FACTOR ;
     data_item->service_id = client_id ;
     data_item->destination_key = destination  ;
-    data_item->flags = 0 ;	// this is unused for now.
+    data_item->flags = RsGRouterItemFlags::NONE ;	// this is unused for now.
 
     // First, encrypt.
 
@@ -2204,8 +2278,12 @@ return true ;
 
 Sha1CheckSum p3GRouter::makeTunnelHash(const RsGxsId& destination,const GRouterServiceId& client)
 {
-    assert(  destination.SIZE_IN_BYTES == 16) ;
+	static_assert( RsGxsId::SIZE_IN_BYTES == 16,
-    assert(Sha1CheckSum::SIZE_IN_BYTES == 20) ;
+	               "This function breaks if RsGxsId size changes" );
+	static_assert( Sha1CheckSum::SIZE_IN_BYTES == 20,
+	               "This function breaks if Sha1CheckSum size changes" );
+	static_assert( sizeof(client) == 4,
+	               "This function breaks if client service id size changes" );
 
     uint8_t bytes[20] ;
     memcpy(bytes,destination.toByteArray(),16) ;

libretroshare/src/grouter/p3grouter.h

@@ -22,8 +22,8 @@
 #pragma once
 
 #include <map>
-#include <queue>
 #include <fstream>
+#include <list>
 
 #include "retroshare/rsgrouter.h"
 #include "retroshare/rstypes.h"
@@ -33,15 +33,13 @@
 #include "turtle/turtleclientservice.h"
 #include "services/p3service.h"
 #include "pqi/p3cfgmgr.h"
-
+#include "util/rsdebug.h"
 #include "groutertypes.h"
 #include "groutermatrix.h"
 #include "grouteritems.h"
 
 // To be put in pqi/p3cfgmgr.h
-//
 static const uint32_t CONFIG_TYPE_GROUTER = 0x0016 ;
-static const uint32_t RS_GROUTER_DATA_FLAGS_ENCRYPTED = 0x0001 ;
 
 class p3LinkMgr ;
 class p3turtle ;
@@ -126,7 +124,8 @@ public:
     //         Routing clue collection methods           //
     //===================================================//
 
-    virtual void addRoutingClue(const GRouterKeyId& id,const RsPeerId& peer_id) ;
+	virtual void addRoutingClue(
+	        const RsGxsId& id, const RsPeerId& peer_id) override;
 
     //===================================================//
     //         Client/server request services            //
@@ -220,7 +219,7 @@ private:
     void handleLowLevelTransactionChunkItem(RsGRouterTransactionChunkItem *chunk_item);
     void handleLowLevelTransactionAckItem(RsGRouterTransactionAcknItem*) ;
 
-    static Sha1CheckSum computeDataItemHash(RsGRouterGenericDataItem *data_item);
+    static Sha1CheckSum computeDataItemHash(const RsGRouterGenericDataItem *data_item);
 
     std::ostream& grouter_debug() const
     {
@@ -238,8 +237,9 @@ private:
 
     void handleIncoming() ;
 
-    void handleIncomingReceiptItem(RsGRouterSignedReceiptItem *receipt_item) ;
+	void handleIncomingItem(const RsGRouterAbstractMsgItem *item);
-    void handleIncomingDataItem(RsGRouterGenericDataItem *data_item) ;
+    void handleIncomingReceiptItem(const RsGRouterSignedReceiptItem *receipt_item) ;
+    void handleIncomingDataItem(const RsGRouterGenericDataItem *data_item) ;
 
     bool locked_getLocallyRegisteredClientFromServiceId(const GRouterServiceId& service_id,GRouterClientService *& client);
 
@@ -252,7 +252,7 @@ private:
 
     // signs an item with the given key.
     bool signDataItem(RsGRouterAbstractMsgItem *item,const RsGxsId& id) ;
-    bool verifySignedDataItem(RsGRouterAbstractMsgItem *item, const RsIdentityUsage::UsageCode &info, uint32_t &error_status) ;
+    bool verifySignedDataItem(const RsGRouterAbstractMsgItem *item, const RsIdentityUsage::UsageCode &info, uint32_t &error_status) ;
     bool encryptDataItem(RsGRouterGenericDataItem *item,const RsGxsId& destination_key) ;
     bool decryptDataItem(RsGRouterGenericDataItem *item) ;
 
@@ -352,4 +352,23 @@ private:
     rstime_t _last_config_changed ;
 
     uint64_t _random_salt ;
+
+	/** Temporarly store items that could not have been verified yet due to
+	 * missing author key, attempt to handle them once in a while.
+	 * The items are discarded if after mMissingKeyQueueEntryTimeout the key
+	 * hasn't been received yet, and are not saved on RetroShare stopping. */
+	std::list< std::pair<
+	    std::unique_ptr<RsGRouterAbstractMsgItem>, rstime_t > > mMissingKeyQueue;
+	RsMutex mMissingKeyQueueMtx; /// protect mMissingKeyQueue
+
+	/// @see mMissingKeyQueue
+	static constexpr rstime_t mMissingKeyQueueEntryTimeout = 600;
+
+	/// @see mMissingKeyQueue
+	static constexpr rstime_t mMissingKeyQueueCheckEvery = 30;
+
+	/// @see mMissingKeyQueue
+	rstime_t mMissingKeyQueueCheckLastCheck = 0;
+
+	RS_SET_CONTEXT_DEBUG_LEVEL(2)
 };

libretroshare/src/retroshare/rsgrouter.h

@@ -19,12 +19,13 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.       *
  *                                                                             *
  *******************************************************************************/
-
 #pragma once
 
 #include "util/rsdir.h"
+#include "util/rsdeprecate.h"
 #include "retroshare/rsids.h"
 #include "retroshare/rsgxsifacetypes.h"
+#include "rsitems/rsserviceids.h"
 
 typedef RsGxsId  GRouterKeyId ;	// we use SSLIds, so that it's easier in the GUI to mix up peer ids with grouter ids.
 typedef uint32_t GRouterServiceId ;

libretroshare/src/retroshare/rsidentity.h

@@ -511,9 +511,13 @@ struct RsIdentity : RsGxsIfaceHelper
 	 * @brief request details of a not yet known identity to the network
 	 * @jsonapi{development}
 	 * @param[in] id id of the identity to request
+	 * @param[in] peers optional list of the peers to ask for the key, if empty
+	 *	all online peers are asked.
 	 * @return false on error, true otherwise
 	 */
-	virtual bool requestIdentity(const RsGxsId& id) = 0;
+	virtual bool requestIdentity(
+	        const RsGxsId& id,
+	        const std::vector<RsPeerId>& peers = std::vector<RsPeerId>() ) = 0;
 
 	/// default base URL used for indentity links @see exportIdentityLink
 	static const std::string DEFAULT_IDENTITY_BASE_URL;

libretroshare/src/rsserver/rsinit.cc

@@ -297,6 +297,7 @@ int RsInit::InitRetroShare(const RsConfigOptions& conf)
     rsInitConfig->inet               = conf.forcedInetAddress ;
     rsInitConfig->port               = conf.forcedPort ;
     rsInitConfig->debugLevel         = conf.debugLevel;
+    rsInitConfig->udpListenerOnly    = conf.udpListenerOnly;
     rsInitConfig->optBaseDir         = conf.optBaseDir;
     rsInitConfig->jsonApiPort        = conf.jsonApiPort;
     rsInitConfig->jsonApiBindAddress = conf.jsonApiBindAddress;

libretroshare/src/services/p3idservice.cc

@@ -1163,91 +1163,88 @@ bool p3IdService::havePrivateKey(const RsGxsId &id)
     if(! isOwnId(id))
         return false ;
 
-    RsStackMutex stack(mIdMtx); /********** STACK LOCKED MTX ******/
+	RS_STACK_MUTEX(mIdMtx);
-    return mKeyCache.is_cached(id) ;
+	return mKeyCache.is_cached(id);
 }
 
 static void mergeIds(std::map<RsGxsId,std::list<RsPeerId> >& idmap,const RsGxsId& id,const std::list<RsPeerId>& peers)
 {
-    // merge the two lists (I use a std::set to make it more efficient)
+	/* merge the two lists, use std::set to avoid duplicates efficiently */
-#ifdef DEBUG_IDS
-    std::cerr << "p3IdService::requestKey(): merging list with existing pending request." << std::endl;
-#endif
 
-    std::list<RsPeerId>& old_peers(idmap[id]) ;	// create if necessary
+	std::set<RsPeerId> new_peers(std::begin(peers), std::end(peers));
-    std::set<RsPeerId> new_peers ;
 
-    for(std::list<RsPeerId>::const_iterator it(peers.begin());it!=peers.end();++it)
+	std::list<RsPeerId>& stored_peers(idmap[id]);
-        new_peers.insert(*it) ;
+	std::copy( std::begin(stored_peers), std::end(stored_peers),
-
+	           std::inserter(new_peers, std::begin(new_peers)) );
-    for(std::list<RsPeerId>::iterator it(old_peers.begin());it!=old_peers.end();++it)
+	stored_peers.clear();
-        new_peers.insert(*it) ;
+	std::copy( std::begin(new_peers), std::end(new_peers),
-
+	           std::inserter(stored_peers, std::begin(stored_peers)) );
-    old_peers.clear();
-
-    for(std::set<RsPeerId>::iterator it(new_peers.begin());it!=new_peers.end();++it)
-        old_peers.push_back(*it) ;
 }
 
-bool p3IdService::requestIdentity(const RsGxsId& id)
+bool p3IdService::requestIdentity(
+        const RsGxsId& id, const std::vector<RsPeerId>& peers )
 {
+	std::list<RsPeerId> askPeersList(peers.begin(), peers.end());
+
+	// Empty list passed? Ask to all online peers.
+	if(askPeersList.empty()) rsPeers->getOnlineList(askPeersList);
+
+	if(askPeersList.empty()) // Still empty? Fail!
+	{
+		RsErr() << __PRETTY_FUNCTION__ << " failure retrieving peers list"
+		        << std::endl;
+		return false;
+	}
+
 	RsIdentityUsage usageInfo( RsServiceType::GXSID,
 	                           RsIdentityUsage::IDENTITY_DATA_UPDATE );
-	std::list<RsPeerId> onlinePeers;
 
-	return rsPeers && rsPeers->getOnlineList(onlinePeers)
+	return requestKey(id, askPeersList, usageInfo);
-	        && requestKey(id, onlinePeers, usageInfo);
 }
 
 bool p3IdService::requestKey(const RsGxsId &id, const std::list<RsPeerId>& peers,const RsIdentityUsage& use_info)
 {
+	Dbg3() << __PRETTY_FUNCTION__ << " id: " <<  id << std::endl;
+
 	if(id.isNull())
 	{
-        std::cerr << "(EE) nul ID requested to p3IdService. This should not happen. Callstack:" << std::endl;
+		RsErr() << __PRETTY_FUNCTION__ << " cannot request null id"
-        print_stacktrace();
+		        << std::endl;
-        return false ;
+		return false;
 	}
 
-    if (haveKey(id))
+	if(peers.empty())
-        return true;
-    else
 	{
-        // Normally we should call getIdDetails(), but since the key is not known, we need to digg a possibly old information
+		RsErr() << __PRETTY_FUNCTION__ << " cannot request id: " << id
-        // from the reputation system, which keeps its own list of banned keys. Of course, the owner ID is not known at this point.
+		        << " to empty lists of peers" << std::endl;
+		return false;
+	}
 
-#ifdef DEBUG_IDS
+	if(isKnownId(id)) return true;
-        std::cerr << "p3IdService::requesting key " << id <<std::endl;
+
-#endif
+	/* Normally we should call getIdDetails(), but since the key is not known,
+	 * we need to dig a possibly old information from the reputation system,
+	 * which keeps its own list of banned keys.
+	 * Of course, the owner ID is not known at this point.c*/
 
 	RsReputationInfo info;
-        rsReputations->getReputationInfo(id,RsPgpId(),info) ;
+	rsReputations->getReputationInfo(id, RsPgpId(), info);
 
 	if( info.mOverallReputationLevel == RsReputationLevel::LOCALLY_NEGATIVE )
 	{
-            std::cerr << "(II) not requesting Key " << id << " because it has been banned." << std::endl;
+		RsInfo() << __PRETTY_FUNCTION__ << " not requesting Key " << id
+		         << " because it has been banned." << std::endl;
+
+		RS_STACK_MUTEX(mIdMtx);
+		mIdsNotPresent.erase(id);
+
+		return false;
+	}
 
 	{
-                RS_STACK_MUTEX(mIdMtx); /********** STACK LOCKED MTX ******/
+		RS_STACK_MUTEX(mIdMtx);
-                mIdsNotPresent.erase(id) ;
+		mergeIds(mIdsNotPresent, id, peers);
-            }
+		mKeysTS[id].usage_map[use_info] = time(nullptr);
-            return true;
-        }
-
-        RsStackMutex stack(mIdMtx); /********** STACK LOCKED MTX ******/
-
-        std::map<RsGxsId,std::list<RsPeerId> >::iterator rit = mIdsNotPresent.find(id) ;
-
-        if(rit != mIdsNotPresent.end())
-        {
-            if(!peers.empty())
-                mergeIds(mIdsNotPresent,id,peers) ;
-
-            return true ;
-        }
-    }
-    {
-		RS_STACK_MUTEX(mIdMtx); /********** STACK LOCKED MTX ******/
-		mKeysTS[id].usage_map[use_info] = time(NULL) ;
 	}
 
     return cache_request_load(id, peers);
@@ -2772,31 +2769,27 @@ bool p3IdService::cache_store(const RsGxsIdGroupItem *item)
 
 bool p3IdService::cache_request_load(const RsGxsId &id, const std::list<RsPeerId> &peers)
 {
-#ifdef DEBUG_IDS
+	Dbg4() << __PRETTY_FUNCTION__ << " id: " << id << std::endl;
-    std::cerr << "p3IdService::cache_request_load(" << id << ")" << std::endl;
-#endif // DEBUG_IDS
 
 	{
-        RsStackMutex stack(mIdMtx); /********** STACK LOCKED MTX ******/
+		RS_STACK_MUTEX(mIdMtx);
-
+		// merge, even if peers is empty
-        mergeIds(mCacheLoad_ToCache,id,peers) ;	// merge, even if peers is empty
+		mergeIds(mCacheLoad_ToCache, id, peers);
 	}
 
-    if (RsTickEvent::event_count(GXSID_EVENT_CACHELOAD) > 0)
+	if(RsTickEvent::event_count(GXSID_EVENT_CACHELOAD) > 0)
 	{
-        /* its already scheduled */
+		Dbg3() << __PRETTY_FUNCTION__ << " cache reload already scheduled "
+		       << "skipping" << std::endl;
 		return true;
 	}
 
 	int32_t age = 0;
-    if (RsTickEvent::prev_event_ago(GXSID_EVENT_CACHELOAD, age))
+	if( RsTickEvent::prev_event_ago(GXSID_EVENT_CACHELOAD, age) && age < MIN_CYCLE_GAP )
-    {
-        if (age < MIN_CYCLE_GAP)
 	{
 		RsTickEvent::schedule_in(GXSID_EVENT_CACHELOAD, MIN_CYCLE_GAP - age);
 		return true;
 	}
-    }
 
 	RsTickEvent::schedule_now(GXSID_EVENT_CACHELOAD);
 	return true;
@@ -2923,70 +2916,87 @@ bool p3IdService::cache_load_for_token(uint32_t token)
 
 void p3IdService::requestIdsFromNet()
 {
-    RsStackMutex stack(mIdMtx);
+	RS_STACK_MUTEX(mIdMtx);
 
 	if(!mNes)
 	{
-        std::cerr << "(WW) cannot request missing GXS IDs because network service is not present." << std::endl;
+		RsErr() << __PRETTY_FUNCTION__ << " Cannot request missing GXS IDs "
-        return ;
+		        << "because network service is not present." << std::endl;
+		return;
 	}
 
     std::map<RsGxsId, std::list<RsPeerId> >::iterator cit;
     std::map<RsPeerId, std::list<RsGxsId> > requests;
 
-    // Transform to appropriate structure (<peer, std::list<RsGxsId> > map) to make request to nes per peer ID
+	/* Transform to appropriate structure (<RsPeerId, std::list<RsGxsId> > map)
-    // Only delete entries in mIdsNotPresent that can actually be performed.
+	 * to make request to nes per peer ID
+	 * Only delete entries in mIdsNotPresent that can actually be performed, or
+	 * that have empty peer list */
 
 	for(cit = mIdsNotPresent.begin(); cit != mIdsNotPresent.end();)
 	{
-#ifdef DEBUG_IDS
+		Dbg2() << __PRETTY_FUNCTION__ << " Processing missing key RsGxsId: "
-        std::cerr << "p3IdService::requestIdsFromNet() Id not found, deferring for net request: " << cit->first << std::endl;
+		       << cit->first << std::endl;
-#endif
 
+		const RsGxsId& gxsId = cit->first;
 		const std::list<RsPeerId>& peers = cit->second;
 		std::list<RsPeerId>::const_iterator cit2;
 
         bool request_can_proceed = false ;
 
 		for(cit2 = peers.begin(); cit2 != peers.end(); ++cit2)
-            if(rsPeers->isOnline(*cit2) || mNes->isDistantPeer(*cit2)) // make sure that the peer in online, so that we know that the request has some chance to succeed.
 		{
-                requests[*cit2].push_back(cit->first);
+			const RsPeerId& peer = *cit2;
+
+			if(rsPeers->isOnline(peer) || mNes->isDistantPeer(peer))
+			{
+				/* make sure that the peer in online, so that we know that the
+				 * request has some chance to succeed.*/
+				requests[peer].push_back(cit->first);
 				request_can_proceed = true ;
-#ifdef DEBUG_IDS
+
-                std::cerr << "       will ask ID " << cit->first << " to peer ID " << *cit2 << std::endl;
+				Dbg2() << __PRETTY_FUNCTION__ << " Moving missing key RsGxsId:"
-#endif
+				       << gxsId << " to peer: " << peer << " requests queue"
+				       << std::endl;
+			}
 		}
 
-        if(request_can_proceed || peers.empty())
+		const bool noPeersFound = peers.empty();
+		if(noPeersFound)
+			RsWarn() << __PRETTY_FUNCTION__ << " No peers supplied to request "
+			         << "RsGxsId: " << gxsId << " dropping." << std::endl;
+
+		if(request_can_proceed || noPeersFound)
 		{
 			std::map<RsGxsId, std::list<RsPeerId> >::iterator tmp(cit);
-            ++tmp ;
+			++tmp;
-            mIdsNotPresent.erase(cit) ;
+			mIdsNotPresent.erase(cit);
-            cit = tmp ;
+			cit = tmp;
 		}
 		else
 		{
-#ifdef DEBUG_IDS
+			RsInfo() << __PRETTY_FUNCTION__ << " no online peers among supplied"
-            std::cerr << "(EE) no online peers among supply list in ID request for groupId " << cit->first << ". Keeping it until peers show up."<< std::endl;
+			         << " list in request for RsGxsId: " << gxsId
-#endif
+			         << ". Keeping it until peers show up."<< std::endl;
-            ++cit ;
+			++cit;
 		}
 	}
 
-    for(std::map<RsPeerId, std::list<RsGxsId> >::const_iterator cit2(requests.begin()); cit2 != requests.end(); ++cit2)
+	for( std::map<RsPeerId, std::list<RsGxsId> >::const_iterator cit2(
+	         requests.begin() ); cit2 != requests.end(); ++cit2 )
 	{
-        std::list<RsGxsId>::const_iterator gxs_id_it = cit2->second.begin();
+		const RsPeerId& peer = cit2->first;
 		std::list<RsGxsGroupId> grpIds;
-        for(; gxs_id_it != cit2->second.end(); ++gxs_id_it)
+		for( std::list<RsGxsId>::const_iterator gxs_id_it = cit2->second.begin();
+		     gxs_id_it != cit2->second.end(); ++gxs_id_it )
 		{
-#ifdef DEBUG_IDS
+			Dbg2() << __PRETTY_FUNCTION__ << " passing RsGxsId: " << *gxs_id_it
-            std::cerr << "  asking ID " << *gxs_id_it << " to peer ID " << cit2->first << std::endl;
+			       << " request for peer: " << peer
-#endif
+			       << " to RsNetworkExchangeService " << std::endl;
 			grpIds.push_back(RsGxsGroupId(*gxs_id_it));
 		}
 
-        mNes->requestGrp(grpIds, cit2->first);
+		mNes->requestGrp(grpIds, peer);
 	}
 }
 
@@ -4699,12 +4709,10 @@ void p3IdService::handle_event(uint32_t event_type, const std::string &/*elabel*
 		case GXSID_EVENT_REQUEST_IDS:
 			requestIdsFromNet();
 		    break;
-
-
 	default:
-			/* error */
+		RsErr() << __PRETTY_FUNCTION__ << " Unknown Event Type: "
-			std::cerr << "p3IdService::handle_event() Unknown Event Type: " << event_type;
+		        << event_type << std::endl;
-			std::cerr << std::endl;
+		print_stacktrace();
 		break;
 	}
 }

libretroshare/src/services/p3idservice.h

@@ -381,7 +381,10 @@ public:
 	                                           RsGxsId* id = nullptr);
 
 	/// @see RsIdentity
-	bool requestIdentity(const RsGxsId& id) override;
+	bool requestIdentity(
+	            const RsGxsId& id,
+	            const std::vector<RsPeerId>& peers = std::vector<RsPeerId>()
+	        ) override;
 
 	/**************** RsGixsReputation Implementation ****************/
 
@@ -494,7 +497,7 @@ private:
 
 	/* MUTEX PROTECTED DATA (mIdMtx - maybe should use a 2nd?) */
 
-	std::map<RsPgpId, PGPFingerprintType> mPgpFingerprintMap;
+	std::map<RsPgpId, RsPgpFingerprint> mPgpFingerprintMap;
 	std::list<RsGxsIdGroup> mGroupsToProcess;
 
 	/************************************************************************
@@ -633,5 +636,5 @@ private:
 	bool mAutoAddFriendsIdentitiesAsContacts;
 	uint32_t mMaxKeepKeysBanned;
 
-	RS_SET_CONTEXT_DEBUG_LEVEL(1)
+	RS_SET_CONTEXT_DEBUG_LEVEL(2)
 };

libretroshare/src/tcponudp/bss_tou.cc

@@ -137,7 +137,7 @@ static int tou_socket_read(BIO *b, char *out, int outl)
 
 	int ret=0;
 
-	if (!out)
+	if (out)
 	{
 		clear_tou_socket_error(BIO_get_fd(b,NULL));
 		/* call tou library */

retroshare-gui/src/gui/chat/ChatWidget.cpp

@@ -390,13 +390,24 @@ void ChatWidget::init(const ChatId &chat_id, const QString &title)
 				// it can happen that a message is first added to the message history
 				// and later the gui receives the message through notify
 				// avoid this by not adding history entries if their age is < 2secs
-                if ((time(NULL)-2) <= historyIt->recvTime)
+				if (time(nullptr) <= historyIt->recvTime+2)
 					continue;
 
 				QString name;
 				if (chatId.isLobbyId() || chatId.isDistantChatId())
 				{
 					RsIdentityDetails details;
+					time_t start = time(nullptr);
+					while (!rsIdentity->getIdDetails(RsGxsId(historyIt->peerName), details))
+					{
+						std::this_thread::sleep_for(std::chrono::milliseconds(10));
+						if (time(nullptr)>start+2)
+						{
+							std::cerr << "ChatWidget History haven't found Id Details and have wait 1 sec for it." << std::endl;
+							break;
+						}
+					}
+
 					if (rsIdentity->getIdDetails(RsGxsId(historyIt->peerName), details))
 						name = QString::fromUtf8(details.mNickname.c_str());
 					else

retroshare-gui/src/gui/feeds/GxsChannelPostItem.cpp

@@ -76,59 +76,6 @@ void GxsChannelPostItem::init(const RsGxsMessageId& messageId,const std::set<RsG
 	mLoaded = false ;
 }
 
-// This code has been suspended because it adds more complexity than usefulness.
-// It was used to load a channel post where the post item is already known.
-
-#ifdef SUSPENDED
-GxsChannelPostItem::GxsChannelPostItem(FeedHolder *feedHolder, uint32_t feedId, const RsGxsChannelGroup &group, const RsGxsChannelPost &post, bool isHome, bool autoUpdate) :
-    GxsFeedItem(feedHolder, feedId, post.mMeta.mGroupId, post.mMeta.mMsgId, isHome, rsGxsChannels, autoUpdate)
-{
-#ifdef DEBUG_ITEM
-	std::cerr << "GxsChannelPostItem::GxsChannelPostItem() Direct Load";
-	std::cerr << std::endl;
-#endif
-
-	QVector<RsGxsMessageId> v;
-    bool self = false;
-
-	for(std::set<RsGxsMessageId>::const_iterator it(post.mOlderVersions.begin());it!=post.mOlderVersions.end();++it)
-    {
-        if(*it == post.mMeta.mMsgId)
-            self = true ;
-
-		v.push_back(*it) ;
-    }
-    if(!self)
-        v.push_back(post.mMeta.mMsgId);
-
-    setMessageVersions(v) ;
-
-	setup();
-
-	setGroup(group, false);
-
-	setPost(post,false);
-	mLoaded = false ;
-}
-
-GxsChannelPostItem::GxsChannelPostItem(FeedHolder *feedHolder, uint32_t feedId, const RsGxsChannelPost &post, bool isHome, bool autoUpdate) :
-    GxsFeedItem(feedHolder, feedId, post.mMeta.mGroupId, post.mMeta.mMsgId, isHome, rsGxsChannels, autoUpdate)
-{
-#ifdef DEBUG_ITEM
-	std::cerr << "GxsChannelPostItem::GxsChannelPostItem() Direct Load";
-	std::cerr << std::endl;
-#endif
-
-	setup();
-
-	mLoaded = true ;
-	requestGroup();
-	setPost(post);
-	requestComment();
-}
-#endif
-
-
 void GxsChannelPostItem::paintEvent(QPaintEvent *e)
 {
 	/* This method employs a trick to trigger a deferred loading. The post and group is requested only
@@ -169,7 +116,6 @@ void GxsChannelPostItem::setup()
 
 	/* clear ui */
 	ui->titleLabel->setText(tr("Loading"));
-	ui->subjectLabel->clear();
 	ui->datetimelabel->clear();
 	ui->filelabel->clear();
 	ui->newCommentLabel->hide();
@@ -208,7 +154,7 @@ void GxsChannelPostItem::setup()
 	ui->warning_label->hide();
 
 	ui->titleLabel->setMinimumWidth(100);
-	ui->subjectLabel->setMinimumWidth(100);
+	//ui->subjectLabel->setMinimumWidth(100);
 	ui->warning_label->setMinimumWidth(100);
 
 	ui->mainFrame->setProperty("new", false);
@@ -431,7 +377,7 @@ void GxsChannelPostItem::fill()
 		ui->titleLabel->setText(title);
 
 		RetroShareLink msgLink = RetroShareLink::createGxsMessageLink(RetroShareLink::TYPE_CHANNEL, mPost.mMeta.mGroupId, mPost.mMeta.mMsgId, messageName());
-		ui->subjectLabel->setText(msgLink.toHtml());
+		//ui->subjectLabel->setText(msgLink.toHtml());
 
 		if (IS_GROUP_SUBSCRIBED(mGroup.mMeta.mSubscribeFlags) || IS_GROUP_ADMIN(mGroup.mMeta.mSubscribeFlags))
 		{
@@ -454,10 +400,10 @@ void GxsChannelPostItem::fill()
 		/* subject */
 		ui->titleLabel->setText(QString::fromUtf8(mPost.mMeta.mMsgName.c_str()));
 
-		uint32_t autorized_lines = (int)floor((ui->logoLabel->height() - ui->titleLabel->height() - ui->buttonHLayout->sizeHint().height())/QFontMetricsF(ui->subjectLabel->font()).height());
+		//uint32_t autorized_lines = (int)floor((ui->logoLabel->height() - ui->titleLabel->height() - ui->buttonHLayout->sizeHint().height())/QFontMetricsF(ui->subjectLabel->font()).height());
 
 		// fill first 4 lines of message. (csoler) Disabled the replacement of smileys and links, because the cost is too crazy
-		ui->subjectLabel->setText(RsHtml().formatText(NULL, RsStringUtil::CopyLines(QString::fromUtf8(mPost.mMsg.c_str()), autorized_lines), RSHTML_FORMATTEXT_EMBED_SMILEYS | RSHTML_FORMATTEXT_EMBED_LINKS));
+		//ui->subjectLabel->setText(RsHtml().formatText(NULL, RsStringUtil::CopyLines(QString::fromUtf8(mPost.mMsg.c_str()), autorized_lines), RSHTML_FORMATTEXT_EMBED_SMILEYS | RSHTML_FORMATTEXT_EMBED_LINKS));
 
 		//ui->subjectLabel->setText(RsStringUtil::CopyLines(QString::fromUtf8(mPost.mMsg.c_str()), 2)) ;
 
@@ -525,7 +471,13 @@ void GxsChannelPostItem::fill()
 		voteDownButton->setEnabled(false);
 	}*/
 
-	ui->msgFrame->setVisible(!mPost.mMsg.empty());
+	{
+		QTextDocument doc;
+		doc.setHtml( QString::fromUtf8(mPost.mMsg.c_str()) );
+
+		ui->msgFrame->setVisible(doc.toPlainText().length() > 0);
+	}
+
 	if (wasExpanded() || ui->expandFrame->isVisible()) {
 		fillExpandFrame();
 	}
@@ -534,7 +486,7 @@ void GxsChannelPostItem::fill()
 
 	if ( (mPost.mCount != 0) || (mPost.mSize != 0) ) {
 		ui->filelabel->setVisible(true);
-		ui->filelabel->setText(QString("(%1 %2) %3").arg(mPost.mCount).arg(tr("Files")).arg(misc::friendlyUnit(mPost.mSize)));
+		ui->filelabel->setText(QString("(%1 %2) %3").arg(mPost.mCount).arg(  (mPost.mCount > 1)?tr("Files"):tr("File")).arg(misc::friendlyUnit(mPost.mSize)));
 	} else {
 		ui->filelabel->setVisible(false);
 	}
@@ -578,6 +530,7 @@ void GxsChannelPostItem::fill()
 void GxsChannelPostItem::fillExpandFrame()
 {
 	ui->msgLabel->setText(RsHtml().formatText(NULL, QString::fromUtf8(mPost.mMsg.c_str()), RSHTML_FORMATTEXT_EMBED_SMILEYS | RSHTML_FORMATTEXT_EMBED_LINKS));
+
 }
 
 QString GxsChannelPostItem::messageName()

retroshare-gui/src/gui/feeds/GxsChannelPostItem.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>1359</width>
+    <width>1433</width>
-    <height>342</height>
+    <height>541</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gxsChannelPostItem_GLayout">
@@ -49,10 +49,12 @@
      <layout class="QVBoxLayout" name="mainFrameVLayout">
       <item>
        <layout class="QHBoxLayout" name="mainTopHLayout">
+        <item>
+         <layout class="QVBoxLayout" name="verticalLayout">
           <item>
            <widget class="QLabel" name="logoLabel">
             <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+             <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
@@ -71,6 +73,8 @@
             </property>
            </widget>
           </item>
+         </layout>
+        </item>
         <item>
          <layout class="QVBoxLayout" name="mainRTopVLayout">
           <item>
@@ -114,41 +118,18 @@
               </property>
              </widget>
             </item>
-           </layout>
-          </item>
             <item>
-           <layout class="QHBoxLayout" name="subjectHLayout">
+             <widget class="QLabel" name="newLabel">
-            <item>
-             <widget class="QLabel" name="subjectLabel">
-              <property name="sizePolicy">
-               <sizepolicy hsizetype="MinimumExpanding" vsizetype="Expanding">
-                <horstretch>0</horstretch>
-                <verstretch>0</verstretch>
-               </sizepolicy>
-              </property>
               <property name="text">
-               <string notr="true">Short Description</string>
+               <string>New</string>
-              </property>
-              <property name="wordWrap">
-               <bool>true</bool>
-              </property>
-              <property name="openExternalLinks">
-               <bool>true</bool>
-              </property>
-             </widget>
-            </item>
-            <item>
-             <widget class="QLabel" name="filelabel">
-              <property name="text">
-               <string notr="true">fileLabel</string>
-              </property>
-              <property name="alignment">
-               <set>Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing</set>
               </property>
              </widget>
             </item>
            </layout>
           </item>
+          <item>
+           <layout class="QHBoxLayout" name="subjectHLayout"/>
+          </item>
           <item>
            <layout class="QHBoxLayout" name="warningHLayout">
             <item>
@@ -234,13 +215,6 @@
               </property>
              </widget>
             </item>
-            <item>
-             <widget class="QLabel" name="newLabel">
-              <property name="text">
-               <string>New</string>
-              </property>
-             </widget>
-            </item>
             <item>
              <widget class="QLabel" name="scoreLabel">
               <property name="font">
@@ -335,19 +309,6 @@
               </property>
              </widget>
             </item>
-            <item>
-             <spacer name="horizontalSpacer">
-              <property name="orientation">
-               <enum>Qt::Horizontal</enum>
-              </property>
-              <property name="sizeHint" stdset="0">
-               <size>
-                <width>40</width>
-                <height>20</height>
-               </size>
-              </property>
-             </spacer>
-            </item>
             <item>
              <widget class="QPushButton" name="copyLinkButton">
               <property name="sizePolicy">
@@ -368,6 +329,16 @@
               </property>
              </widget>
             </item>
+            <item>
+             <widget class="QLabel" name="filelabel">
+              <property name="text">
+               <string notr="true">fileLabel</string>
+              </property>
+              <property name="alignment">
+               <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+              </property>
+             </widget>
+            </item>
             <item>
              <widget class="QPushButton" name="unsubscribeButton">
               <property name="sizePolicy">
@@ -387,6 +358,19 @@
               </property>
              </widget>
             </item>
+            <item>
+             <spacer name="horizontalSpacer_2">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
             <item>
              <widget class="QPushButton" name="expandButton">
               <property name="sizePolicy">