first version of distant messages. Still needs some debugging

git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-GenericTunneling@6344 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libretroshare/src/retroshare/rsmsgs.h

@@ -221,6 +221,14 @@ bool operator==(const ChatInfo&, const ChatInfo&);
 class RsMsgs;
 extern RsMsgs   *rsMsgs;
 
+struct DistantOfflineMessengingInvite
+{
+	std::string issuer_pgp_id ;
+	std::string hash ;
+	time_t time_of_validity ;
+};
+
+
 class RsMsgs 
 {
 	public:
@@ -260,6 +268,11 @@ virtual bool setMessageTag(const std::string &msgId, uint32_t tagId, bool set) =
 
 virtual bool resetMessageStandardTagTypes(MsgTagType& tags) = 0;
 
+/* private distant messages */
+
+virtual bool createDistantOfflineMessengingInvite(time_t validity_time_stamp, std::string& hash)=0 ;
+virtual bool getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>& invites) = 0 ;
+
 /****************************************/
 /*                 Chat                 */
 /****************************************/

libretroshare/src/rsserver/p3msgs.cc

@@ -96,6 +96,16 @@ bool p3Msgs::MessageSend(MessageInfo &info)
 	return mMsgSrv->MessageSend(info);
 }
 
+bool p3Msgs::createDistantOfflineMessengingInvite(time_t ts, std::string& hash) 
+{
+	return mMsgSrv->createDistantOfflineMessengingInvite(ts,hash) ;
+}
+bool p3Msgs::getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>& invites)
+{
+	return mMsgSrv->getDistantOfflineMessengingInvites(invites);
+}
+
+
 bool p3Msgs::SystemMessage(const std::wstring &title, const std::wstring &message, uint32_t systemFlag)
 {
 	return mMsgSrv->SystemMessage(title, message, systemFlag);

libretroshare/src/rsserver/p3msgs.h

@@ -78,6 +78,9 @@ class p3Msgs: public RsMsgs
 
 	  virtual bool resetMessageStandardTagTypes(MsgTagType& tags);
 
+	  virtual bool createDistantOfflineMessengingInvite(time_t, std::string&) ;
+	  virtual bool getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>&);
+
 	  /*!
 	   * gets avatar from peer, image data in jpeg format
 	   */

libretroshare/src/serialiser/rsmsgitems.h

@@ -406,6 +406,8 @@ const uint32_t RS_MSG_FLAGS_PARTIAL               = 0x0400;
 const uint32_t RS_MSG_FLAGS_USER_REQUEST          = 0x0800;
 const uint32_t RS_MSG_FLAGS_FRIEND_RECOMMENDATION = 0x1000;
 const uint32_t RS_MSG_FLAGS_SYSTEM                = RS_MSG_FLAGS_USER_REQUEST | RS_MSG_FLAGS_FRIEND_RECOMMENDATION;
+const uint32_t RS_MSG_FLAGS_RETURN_RECEPT         = 0x2000;
+const uint32_t RS_MSG_FLAGS_ENCRYPTED             = 0x4000;
 
 class RsMsgItem: public RsItem
 {

libretroshare/src/services/p3chatservice.cc

@@ -61,7 +61,7 @@ static const time_t 	MIN_DELAY_BETWEEN_PUBLIC_LOBBY_REQ =   20 ; // don't ask fo
 
 static const time_t 	 DISTANT_CHAT_CLEANING_PERIOD      =   60 ; // don't ask for lobby list more than once every 30 secs.
 static const uint32_t DISTANT_CHAT_AES_KEY_SIZE         =   16 ; // size of AES encryption key for distant chat.
-static const uint32_t DISTANT_CHAT_HASH_SIZE            =   16 ; // This is sha1 size in bytes.
+static const uint32_t DISTANT_CHAT_HASH_SIZE            =   20 ; // This is sha1 size in bytes.
 
 p3ChatService::p3ChatService(p3LinkMgr *lm, p3HistoryMgr *historyMgr)
 	:p3Service(RS_SERVICE_TYPE_CHAT), p3Config(CONFIG_TYPE_CHAT), mChatMtx("p3ChatService"), mLinkMgr(lm) , mHistoryMgr(historyMgr)
@@ -3115,7 +3115,7 @@ bool p3ChatService::createDistantChatInvite(const std::string& pgp_id,time_t tim
 	unsigned char hash_bytes[DISTANT_CHAT_HASH_SIZE] ;
 	RAND_bytes( hash_bytes, DISTANT_CHAT_HASH_SIZE) ;
 
-	std::string hash = SSLIdType(hash_bytes).toStdString(false) ;
+	std::string hash = t_RsGenericIdType<DISTANT_CHAT_HASH_SIZE>(hash_bytes).toStdString(false) ;
 
 	std::cerr << "Created new distant chat invite: " << std::endl;
 	std::cerr << "  validity time stamp = " << invite.time_of_validity << std::endl;

libretroshare/src/services/p3msgservice.cc

@@ -29,6 +29,7 @@
 #include "pqi/pqibin.h"
 #include "pqi/pqiarchive.h"
 #include "pqi/p3linkmgr.h"
+#include "pqi/authgpg.h"
 
 #include "services/p3msgservice.h"
 #include "pqi/pqinotify.h"
@@ -36,12 +37,17 @@
 #include "util/rsdebug.h"
 #include "util/rsdir.h"
 #include "util/rsstring.h"
+#include "util/rsrandom.h"
 
 #include <iomanip>
 #include <map>
 
 const int msgservicezone = 54319;
 
+static const uint32_t RS_DISTANT_MSG_STATUS_TUNNEL_OK = 0x0001 ;
+static const uint32_t RS_DISTANT_MSG_STATUS_TUNNEL_DN = 0x0000 ;
+static const uint32_t DISTANT_MSG_HASH_SIZE = 20 ;
+
 /* Another little hack ..... unique message Ids
  * will be handled in this class.....
  * These are unique within this run of the server, 
@@ -81,6 +87,15 @@ int	p3MsgService::tick()
 	 */
 
 	incomingMsgs(); 
+
+	static time_t last_management_time = 0 ;
+	time_t now = time(NULL) ;
+
+	if(now > last_management_time + 5)
+	{
+		manageDistantPeers() ;
+		last_management_time = now ;
+	}
 	//checkOutgoingMessages(); 
 
 	return 0;
@@ -187,22 +202,27 @@ int p3MsgService::incomingMsgs()
 {
 	RsMsgItem *mi;
 	int i = 0;
-	bool changed = false ;
 
 	while((mi = (RsMsgItem *) recvItem()) != NULL)
 	{
-		changed = true ;
+		handleIncomingItem(mi) ;
 		++i ;
+	}
+
+	return i;
+}
+
+void p3MsgService::handleIncomingItem(RsMsgItem *mi)
+{
+	bool changed = false ;
 
 	if(checkAndRebuildPartialMessage(mi))	// only returns true when a msg is complete.
 	{
 		processMsg(mi, true);
-		}
+		changed = true ;
 	}
 	if(changed)
 		rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_MOD);
-
-	return 1;
 }
 
 void    p3MsgService::statusChange(const std::list<pqipeer> &/*plist*/)
@@ -1562,3 +1582,268 @@ RsMsgItem *p3MsgService::initMIRsMsg(MessageInfo &info, const std::string &to)
 	//msg->print(std::cerr);
 	return msg;
 }
+
+void p3MsgService::connectToTurtleRouter(p3turtle *pt)
+{
+	mTurtle = pt ;
+	pt->registerTunnelService(this) ;
+}
+bool p3MsgService::createDistantOfflineMessengingInvite(time_t time_of_validity,TurtleFileHash& hash) 
+{
+	unsigned char hash_bytes[DISTANT_MSG_HASH_SIZE] ;
+	RSRandom::random_bytes( hash_bytes, DISTANT_MSG_HASH_SIZE) ;
+
+	hash = t_RsGenericIdType<DISTANT_MSG_HASH_SIZE>(hash_bytes).toStdString(false) ;
+
+	DistantMessengingInvite invite ;
+	invite.time_of_validity = time_of_validity ;
+
+	{
+		RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+		_messenging_invites[hash] = invite ;
+	}
+	return true ;
+}
+bool p3MsgService::getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>& invites) 
+{
+	RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+
+	for(std::map<std::string,DistantMessengingInvite>::const_iterator it(_messenging_invites.begin());it!=_messenging_invites.end();++it)
+	{
+		DistantOfflineMessengingInvite invite ;
+		invite.hash = it->first ;
+		invite.issuer_pgp_id = AuthGPG::getAuthGPG()->getGPGOwnId() ;
+		invite.time_of_validity = it->second.time_of_validity ;
+	}
+
+	return true ;
+}
+bool p3MsgService::handleTunnelRequest(const std::string& hash,const std::string& peer_id) 
+{
+	RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+	std::map<std::string,DistantMessengingInvite>::const_iterator it = _messenging_invites.find(hash) ;
+
+	return it != _messenging_invites.end() ;
+}
+
+void p3MsgService::manageDistantPeers()
+{
+	// now possibly flush pending messages
+
+	std::cerr << "p3MsgService::manageDistantPeers()" << std::endl;
+
+	std::vector<std::pair<std::string,RsMsgItem*> > to_send ;
+
+	{
+		RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+		for(std::map<std::string,DistantMessengingContact>::iterator it(_messenging_contacts.begin());it!=_messenging_contacts.end();++it)
+			if(it->second.status == RS_DISTANT_MSG_STATUS_TUNNEL_OK)
+				for(uint32_t i=0;i<it->second.pending_messages.size();++i)
+					to_send.push_back(std::pair<std::string,RsMsgItem*>(it->first,it->second.pending_messages[i])) ;
+	}
+
+	for(uint32_t i=0;i<to_send.size();++i)
+	{
+		std::cerr << "    Flushing msg " << to_send[i].second->msgId << std::endl;
+		sendTurtleData(to_send[i].first,to_send[i].second) ;
+	}
+
+	time_t now = time(NULL) ;
+	{
+		RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+
+		// clean dead invites.
+		//
+		for(std::map<std::string,DistantMessengingInvite>::iterator it(_messenging_invites.begin());it!=_messenging_invites.end();)
+			if(it->second.time_of_validity < now)
+			{
+				std::cerr << "    Removing outdated invite " << it->second.time_of_validity << ", hash=" << it->first << std::endl;
+				std::map<std::string,DistantMessengingInvite>::iterator tmp(it) ;
+				++tmp ;
+				_messenging_invites.erase(it) ;
+				it = tmp ;
+			}
+			else
+				++it ;
+
+		// clean dead contacts.
+		//
+		for(std::map<std::string,DistantMessengingContact>::iterator it(_messenging_contacts.begin());it!=_messenging_contacts.end();)
+			if(it->second.pending_messages.empty() && it->second.status == RS_DISTANT_MSG_STATUS_TUNNEL_DN)
+			{
+				std::cerr << "    Removing dead contact with no pending msgs and dead tunnel. hash=" << it->first << std::endl;
+				std::map<std::string,DistantMessengingContact>::iterator tmp(it) ;
+				++tmp ;
+				_messenging_contacts.erase(it) ;
+				it = tmp ;
+			}
+			else
+				++it ;
+	}
+}
+
+void p3MsgService::addVirtualPeer(const TurtleFileHash& hash, const TurtleVirtualPeerId& vpid,RsTurtleGenericTunnelItem::Direction dir) 
+{
+	RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+	// A new tunnel has been created. We need to flush pending messages for the corresponding peer.
+
+	//std::map<std::string,DistantMessengingContact>::const_iterator it = _messenging_contacts.find(hash) ;
+
+	DistantMessengingContact& contact(_messenging_contacts[hash]) ; // possibly creates it.
+
+	contact.virtual_peer_id = vpid ;
+	contact.last_hit_time = time(NULL) ;
+	contact.status = RS_DISTANT_MSG_STATUS_TUNNEL_OK ;
+
+	std::cerr << "p3MsgService::addVirtualPeer(): adding virtual peer " << vpid << " for hash " << hash << std::endl;
+}
+void p3MsgService::removeVirtualPeer(const TurtleFileHash& hash, const TurtleVirtualPeerId& vpid) 
+{
+	RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+	// A new tunnel has been created. We need to flush pending messages for the corresponding peer.
+
+	//std::map<std::string,DistantMessengingContact>::const_iterator it = _messenging_contacts.find(hash) ;
+
+	DistantMessengingContact& contact(_messenging_contacts[hash]) ; // possibly creates it.
+
+	contact.status = RS_DISTANT_MSG_STATUS_TUNNEL_DN ;
+	contact.virtual_peer_id.clear() ;
+}
+static void printBinaryData(void *data,uint32_t size)
+{
+	static const char outl[16] = { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' } ;
+
+	for(uint32_t j = 0; j < size; j++) 
+	{ 
+		std::cerr << outl[ ( ((uint8_t*)data)[j]>>4) ] ; 
+		std::cerr << outl[ ((uint8_t*)data)[j] & 0xf ] ; 
+	}
+}
+
+void p3MsgService::sendTurtleData(const std::string& hash,RsMsgItem *msgitem) 
+{
+	// The item is serialized and turned into a generic turtle item.
+	
+	uint32_t rssize = _serialiser->size(msgitem) ;
+	unsigned char *data = new unsigned char[rssize] ;
+
+	if(!_serialiser->serialise(msgitem,data,&rssize))
+	{
+		std::cerr << "(EE) p3MsgService::sendTurtleData(): Serialization error." << std::endl;
+		delete[] data ;
+		return ;
+	}
+
+	RsTurtleGenericDataItem *item = new RsTurtleGenericDataItem ;
+	item->data_bytes = malloc(rssize) ;
+	item->data_size = rssize ;
+	memcpy(item->data_bytes,data,rssize) ;
+
+	delete[] data ;
+
+	printBinaryData(item->data_bytes,item->data_size) ;
+	std::cerr << std::endl;
+
+	// do we have a working tunnel for that hash ?
+	// If not, put on the contact's waiting list.
+
+	std::string virtual_peer_id ;
+	{
+		RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+		std::map<std::string,DistantMessengingContact>::const_iterator it = _messenging_contacts.find(hash) ;
+
+		if(it == _messenging_contacts.end())
+		{
+			std::cerr << "(EE) p3MsgService::sendTurtleData(): Can't find hash " << hash << " in recorded contact list." << std::endl;
+			delete[] data ;
+			return ;
+		}
+
+		if(!it->second.status == RS_DISTANT_MSG_STATUS_TUNNEL_OK)
+		{
+			std::cerr << "p3MsgService::sendTurtleData(): tunnel is not ok. Putting items on waiting list." << std::endl;
+			return ;
+		}
+		virtual_peer_id = it->second.virtual_peer_id ;
+	}
+	std::cerr << "p3MsgService::sendTurtleData(): Sending through virtual peer: " << virtual_peer_id << std::endl;
+	std::cerr << "   item->data_size = " << item->data_size << std::endl;
+	std::cerr << "   data = " ;
+
+	mTurtle->sendTurtleData(virtual_peer_id,item) ;
+}
+
+void p3MsgService::receiveTurtleData(RsTurtleGenericTunnelItem *gitem,const std::string& hash,
+												const std::string& virtual_peer_id,RsTurtleGenericTunnelItem::Direction direction) 
+{
+	RsTurtleGenericDataItem *item = dynamic_cast<RsTurtleGenericDataItem*>(gitem) ;
+
+	if(item == NULL)
+	{
+		std::cerr << "(EE) p3MsgService::receiveTurtleData(): item is not a data item. That is an error." << std::endl;
+		return ;
+	}
+	std::cerr << "p3MsgService::sendTurtleData(): Receiving through virtual peer: " << virtual_peer_id << std::endl;
+	std::cerr << "   gitem->data_size = " << item->data_size << std::endl;
+	std::cerr << "   data = " ;
+	printBinaryData(item->data_bytes,item->data_size) ;
+	std::cerr << std::endl;
+
+	{
+		RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+		std::map<std::string,DistantMessengingContact>::iterator it = _messenging_contacts.find(hash) ;
+
+		if(it == _messenging_contacts.end())
+		{
+			std::cerr << "(EE) p3MsgService::sendTurtleData(): Can't find hash " << hash << " in recorded contact list." << std::endl;
+			return ;
+		}
+
+		it->second.status = RS_DISTANT_MSG_STATUS_TUNNEL_OK ;
+		it->second.last_hit_time = time(NULL) ;
+	}
+		
+	RsItem *itm = _serialiser->deserialise(item->data_bytes,&item->data_size) ;
+
+	RsMsgItem *mitm = dynamic_cast<RsMsgItem*>(itm) ;
+
+	if(mitm != NULL)
+	{
+		mitm->PeerId(hash) ;
+		handleIncomingItem(mitm) ;
+	}
+	else
+	{
+		std::cerr << "(EE) p3MsgService::receiveTurtleData(): received item is not a RsMsgItem!!" << std::endl;
+		delete itm ;
+	}
+}
+
+void p3MsgService::sendPrivateMsgItem(RsMsgItem *msgitem) 
+{
+	std::cerr << "p3MsgService::sendDistanteMsgItem(): sending distant msg item to peer " << msgitem->PeerId() << std::endl;
+	std::cerr << "     asking for tunnels" << std::endl;
+	std::cerr << "     recording msg info" << std::endl;
+
+	const std::string& hash = msgitem->PeerId() ;
+	rsTurtle->monitorTunnels(hash,this) ;					 // create a tunnel for it, and put the msg on the waiting list.
+
+	{
+		RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
+
+		// allocate a new contact. If it does not exist, set its tunnel state to DN
+		//
+		std::map<std::string,DistantMessengingContact>::iterator it = _messenging_contacts.find(hash) ;
+		
+		DistantMessengingContact& contact( _messenging_contacts[hash] ) ;
+
+		if(it == _messenging_contacts.end())
+			it->second.status = RS_DISTANT_MSG_STATUS_TUNNEL_DN ;
+
+		contact.pending_messages.push_back(msgitem) ;								 // record the msg to be sent.
+	}
+}
+
+
+
+

libretroshare/src/services/p3msgservice.h

@@ -42,10 +42,12 @@
 #include "services/p3service.h"
 #include "serialiser/rsmsgitems.h"
 #include "util/rsthreads.h"
+#include "turtle/p3turtle.h"
+#include "turtle/turtleclientservice.h"
 
 class p3LinkMgr;
 
-class p3MsgService: public p3Service, public p3Config, public pqiMonitor
+class p3MsgService: public p3Service, public p3Config, public pqiMonitor, public RsTurtleClientService
 {
 	public:
 	p3MsgService(p3LinkMgr *lm);
@@ -97,7 +99,49 @@ virtual void    statusChange(const std::list<pqipeer> &plist);
 int     checkOutgoingMessages();
 	/*** Overloaded from pqiMonitor ***/
 
+	/*** overloaded from p3turtle   ***/
+
+		void connectToTurtleRouter(p3turtle *) ;
+
+		struct DistantMessengingInvite
+		{
+			time_t time_of_validity ;
+		};
+		struct DistantMessengingContact
+		{
+			time_t last_hit_time ;
+			std::string virtual_peer_id ;
+			uint32_t status ;
+			std::vector<RsMsgItem*> pending_messages ;
+		};
+
+		bool createDistantOfflineMessengingInvite(time_t time_of_validity,TurtleFileHash& hash) ;
+		bool getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>& invites) ;
+		void sendPrivateMsgItem(RsMsgItem *) ;
+
 	private:
+		// This maps contains the current invitations to respond to.
+		//
+		std::map<std::string,DistantMessengingInvite> _messenging_invites ;
+
+		// This contains the ongoing tunnel handling contacts.
+		//
+		std::map<std::string,DistantMessengingContact> _messenging_contacts ;
+
+		// Overloaded from RsTurtleClientService
+
+		virtual bool handleTunnelRequest(const std::string& hash,const std::string& peer_id) ;
+		virtual void receiveTurtleData(RsTurtleGenericTunnelItem *item,const std::string& hash,const std::string& virtual_peer_id,RsTurtleGenericTunnelItem::Direction direction) ;
+		void addVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&,RsTurtleGenericTunnelItem::Direction dir) ;
+		void removeVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&) ;
+
+		// Utility functions
+
+		void manageDistantPeers() ;
+		void sendTurtleData(const std::string& hash,RsMsgItem *) ;
+		void handleIncomingItem(RsMsgItem *) ;
+
+		p3turtle *mTurtle ;
 
 uint32_t getNewUniqueMsgId();
 int     sendMessage(RsMsgItem *item);
@@ -118,6 +162,7 @@ void    initStandardTagTypes();
 	/* Mutex Required for stuff below */
 
 	RsMutex mMsgMtx;
+	RsMsgSerialiser *_serialiser ;
 
 		/* stored list of messages */
 	std::map<uint32_t, RsMsgItem *> imsg;

libretroshare/src/turtle/turtleclientservice.h

@@ -63,6 +63,7 @@ class RsTurtleClientService
 		// 			both ways, and their nature cannot suffice to determine where they should be handled.
 		//
 		// By default (if not overloaded), the method will just free the data, as any subclass should do as well.
+		// Note: p3turtle stays owner of the item, so the client should not delete it!
 		//
 		virtual void receiveTurtleData(RsTurtleGenericTunnelItem *item,const std::string& hash,const std::string& virtual_peer_id,RsTurtleGenericTunnelItem::Direction direction) 
 		{ 

libretroshare/src/util/rsrandom.cc

@@ -51,6 +51,10 @@ bool RSRandom::seed(uint32_t s)
 	return true ;
 }
 
+void RSRandom::random_bytes(unsigned char *data,uint32_t size) 
+{
+	RAND_bytes(data,size) ;
+}
 void RSRandom::locked_next_state() 
 {
 #ifdef RSRANDOM_USE_SSL

libretroshare/src/util/rsrandom.h

@@ -46,6 +46,7 @@ class RSRandom
 		static bool     seed(uint32_t s) ;
 
 		static std::string random_alphaNumericString(uint32_t length) ; 
+		static void random_bytes(unsigned char *data,uint32_t length) ; 
 
 	private:
 		static RsMutex rndMtx ;

retroshare-gui/src/gui/CreateMsgLinkDialog.cpp

@@ -1,7 +1,7 @@
 /****************************************************************
  *  RetroShare is distributed under the following license:
  *
- *  Copyright (C) 2008 Robert Fernie
+ *  Copyright (C) 2013 Cyril Soler
  *
  *  This program is free software; you can redistribute it and/or
  *  as published by the Free Software Foundation; either version 2
@@ -22,6 +22,7 @@
 #include <QMessageBox>
 #include <QTimer>
 #include <retroshare/rsmsgs.h>
+#include <retroshare/rspeers.h>
 #include "CreateMsgLinkDialog.h"
 #include <gui/common/FriendSelectionWidget.h>
 #include <gui/RetroShareLink.h>
@@ -119,6 +120,28 @@ void CreateMsgLinkDialog::update()
 
 		_existing_links_LW->insertItem(0,item) ;
 	}
+
+	std::vector<DistantOfflineMessengingInvite> invites2 ;
+
+	rsMsgs->getDistantOfflineMessengingInvites(invites2) ;
+
+	for(uint32_t i=0;i<invites2.size();++i)
+	{
+		RetroShareLink link ;
+
+		if(!link.createPublicMsgInvite(invites2[i].time_of_validity,QString::fromStdString(invites2[i].issuer_pgp_id),QString::fromStdString(invites2[i].hash)))
+			std::cerr << "Cannot create link." << std::endl;
+		else
+		{
+			QListWidgetItem *item = new QListWidgetItem;
+			item->setData(Qt::DisplayRole,tr("Private chat invite to ")+QString::fromStdString(invites2[i].issuer_pgp_id)) ;
+			item->setData(Qt::UserRole,link.toString()) ;
+
+			_existing_links_LW->insertItem(0,item) ;
+		}
+	}
+
+
 }
 
 time_t CreateMsgLinkDialog::computeValidityDuration() const
@@ -174,9 +197,31 @@ void CreateMsgLinkDialog::createLink()
 	}
 	else
 	{
-		std::cerr << "Private msg links not yet implemented." << std::endl;
+		time_t validity_duration = computeValidityDuration() ;
+		std::string hash; 
+		std::string issuer_pgp_id = rsPeers->getGPGOwnId() ;
+
+		bool res = rsMsgs->createDistantOfflineMessengingInvite(validity_duration,hash) ;
+
+		RetroShareLink link ;
+
+		if(!link.createPublicMsgInvite(validity_duration + time(NULL),QString::fromStdString(issuer_pgp_id),QString::fromStdString(hash)) )
+		{
+			std::cerr << "Cannot create link." << std::endl;
+			return ;
 		}
 
-	QTimer::singleShot(500,this,SLOT(update())) ;
+		QList<RetroShareLink> links ;
+		links.push_back(link) ;
+
+		RSLinkClipboard::copyLinks(links) ;
+
+		if(!res)
+			QMessageBox::critical(NULL,tr("Messenging invite creation failed"),tr("The creation of the messenging invite failed")) ;
+		else
+			QMessageBox::information(NULL,tr("Messenging invite created"),tr("Your new messenging chat invite has been copied to clipboard. You can now paste it as a Retroshare link.")) ;
+	}
+
+	QTimer::singleShot(100,this,SLOT(update())) ;
 }
 

retroshare-gui/src/gui/RetroShareLink.cpp

@@ -348,14 +348,14 @@ bool RetroShareLink::createPrivateChatInvite(time_t time_stamp,const QString& gp
 
 	return valid() ;
 }
-bool RetroShareLink::createPublicMsgInvite(time_t time_stamp,const QString& pgp_id,const QString& hash) 
+bool RetroShareLink::createPublicMsgInvite(time_t time_stamp,const QString& issuer_pgp_id,const QString& hash) 
 {
 	clear() ;
 
 	_type = TYPE_PUBLIC_MSG ;
 	_time_stamp = time_stamp ;
 	_hash = hash ;
-	_GPGid = pgp_id ;
+	_GPGid = issuer_pgp_id ;
 
 	check() ;
 
@@ -844,7 +844,9 @@ QString RetroShareLink::niceName() const
 			return QString("Private chat invite (Valid only for key %1)").arg(_GPGid);
 	}
 	if(type() == TYPE_PUBLIC_MSG) {
-		return QString("Click this line to contact %1 (%2)").arg(_GPGid) ;
+			RsPeerDetails detail;
+			rsPeers->getPeerDetails(_GPGid.toStdString(), detail) ;
+		return QString("Click this link to send a private message to %1 (%2)").arg(QString::fromStdString(detail.name)).arg(_GPGid) ;
 	}
 	if(type() == TYPE_CERTIFICATE) {
 		if (_location.isEmpty()) {
@@ -1190,8 +1192,15 @@ static void processList(const QStringList &list, const QString &textSingular, co
 					std::cerr << "Opening a public msg window " << std::endl;
 					std::cerr << "      time_stamp = " << link._time_stamp << std::endl;
 					std::cerr << "      hash       = " << link._hash.toStdString() << std::endl;
-					std::cerr << "      PGP Id     = " << link._GPGid.toStdString() << std::endl;
+					std::cerr << "      Issuer Id  = " << link._GPGid.toStdString() << std::endl;
-					std::cerr << "Feature not yet implemented !" << std::endl;
+
+					if(link._time_stamp < time(NULL))
+					{
+						QMessageBox::information(NULL,QObject::tr("Messenging link is expired"),QObject::tr("This Messenging link is expired. The destination peer will not receive it.")) ;
+						break ;
+					}
+	
+					 MessageComposer::msgFriend(link._hash.toStdString(), false);
 				}
 				break ;
 			case TYPE_PRIVATE_CHAT:

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

@@ -70,19 +70,19 @@ void PopupDistantChatDialog::checkTunnel()
 	{
 		case RS_DISTANT_CHAT_STATUS_UNKNOWN: std::cerr << "Unknown hash. Error!" << std::endl;
 														 _status_label->setPixmap(QPixmap(IMAGE_GRY_LED)) ;
-														  _status_label->setText(tr("Hash error")) ;
+														  _status_label->setToolTip(tr("Hash error")) ;
 														 break ;
 		case RS_DISTANT_CHAT_STATUS_TUNNEL_DN: std::cerr << "Tunnel asked. Waiting for reponse. " << std::endl;
 														 _status_label->setPixmap(QPixmap(IMAGE_RED_LED)) ;
-														  _status_label->setText(tr("Tunnel is broken")) ;
+														  _status_label->setToolTip(tr("Tunnel is broken")) ;
 														 break ;
 		case RS_DISTANT_CHAT_STATUS_TUNNEL_OK: std::cerr << "Tunnel is ok. " << std::endl;
 														 _status_label->setPixmap(QPixmap(IMAGE_YEL_LED)) ;
-														  _status_label->setText(tr("Tunnel established")) ;
+														  _status_label->setToolTip(tr("Tunnel established")) ;
 														 break ;
 		case RS_DISTANT_CHAT_STATUS_CAN_TALK: std::cerr << "Tunnel is ok and works. You can talk!" << std::endl;
 														 _status_label->setPixmap(QPixmap(IMAGE_GRN_LED)) ;
-														  _status_label->setText(tr("Tunnel is working")) ;
+														  _status_label->setToolTip(tr("Tunnel is working")) ;
 														 break ;
 	}
 }