fixed serialisation methods for GxsTunnel service

libretroshare/src/chat/rschatitems.cc

@@ -51,18 +51,6 @@ std::ostream& RsChatMsgItem::print(std::ostream &out, uint16_t indent)
 	printRsItemEnd(out, "RsChatMsgItem", indent);
 	return out;
 }
-std::ostream& RsChatDHPublicKeyItem::print(std::ostream &out, uint16_t indent)
-{
-	printRsItemBase(out, "RsChatDHPublicKeyItem", indent);
-    uint16_t int_Indent = indent + 2;
-
-	printIndent(out, int_Indent);
-	out << "  Signature Key ID: " << signature.keyId << std::endl ;
-	out << "  Public    Key ID: " << gxs_key.keyId << std::endl ;
-
-	printRsItemEnd(out, "RsChatMsgItem", indent);
-	return out;
-}
 
 std::ostream& RsChatLobbyListItem::print(std::ostream &out, uint16_t indent)
 {
@@ -277,7 +265,6 @@ RsItem *RsChatSerialiser::deserialise(void *data, uint32_t *pktsize)
 		case RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_REQUEST:	return new RsChatLobbyListRequestItem(data,*pktsize) ;
 		case RS_PKT_SUBTYPE_CHAT_LOBBY_LIST:        	return new RsChatLobbyListItem(data,*pktsize) ;
         case RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG:  	return new RsChatLobbyConfigItem(data,*pktsize) ;
-        case RS_PKT_SUBTYPE_DISTANT_CHAT_DH_PUBLIC_KEY: return new RsChatDHPublicKeyItem(data,*pktsize) ;
 		default:
 			std::cerr << "Unknown packet type in chat!" << std::endl ;
 			return NULL ;
@@ -437,17 +424,6 @@ uint32_t RsChatLobbyConfigItem::serial_size()
     return s;
 }
 
-uint32_t RsChatDHPublicKeyItem::serial_size()
-{
-	uint32_t s = 8 ;                // header
-	s += 4 ;	                       // BN size
-	s += BN_num_bytes(public_key) ; // public_key
-	s += signature.TlvSize() ;      // signature
-	s += gxs_key.TlvSize() ;        // gxs_key
-
-	return s ;
-}
-
 /*************************************************************************/
 
 RsChatAvatarItem::~RsChatAvatarItem()
@@ -459,41 +435,6 @@ RsChatAvatarItem::~RsChatAvatarItem()
 	}
 }
 
-bool RsChatDHPublicKeyItem::serialise(void *data,uint32_t& pktsize)
-{
-	uint32_t tlvsize = serial_size() ;
-	uint32_t offset = 0;
-
-	if (pktsize < tlvsize)
-		return false; /* not enough space */
-
-	pktsize = tlvsize;
-
-	bool ok = true;
-
-	ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize);
-
-	/* skip the header */
-	offset += 8;
-
-	uint32_t s = BN_num_bytes(public_key) ;
-
-	ok &= setRawUInt32(data, tlvsize, &offset, s);
-
-	BN_bn2bin(public_key,&((unsigned char *)data)[offset]) ;
-	offset += s ;
-
-	ok &= signature.SetTlv(data, tlvsize, &offset);
-	ok &= gxs_key.SetTlv(data, tlvsize, &offset);
-
-	if (offset != tlvsize)
-	{
-		ok = false;
-		std::cerr << "RsChatDHPublicKeyItem::serialiseItem() Size Error! offset=" << offset << ", tlvsize=" << tlvsize << std::endl;
-	}
-	return ok ;
-}
-
 /* serialise the data to the buffer */
 bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize)
 {
@@ -995,28 +936,6 @@ bool RsChatLobbyConfigItem::serialise(void *data, uint32_t& pktsize)
     return ok;
 }
 
-RsChatDHPublicKeyItem::RsChatDHPublicKeyItem(void *data,uint32_t /*size*/)
-	: RsChatItem(RS_PKT_SUBTYPE_DISTANT_CHAT_DH_PUBLIC_KEY)
-{
-	uint32_t offset = 8; // skip the header 
-	uint32_t rssize = getRsItemSize(data);
-	bool ok = true ;
-
-	uint32_t s=0 ;
-	/* get mandatory parts first */
-	ok &= getRawUInt32(data, rssize, &offset, &s);
-
-	public_key = BN_bin2bn(&((unsigned char *)data)[offset],s,NULL) ;
-	offset += s ;
-
-	ok &= signature.GetTlv(data, rssize, &offset) ;
-	ok &= gxs_key.GetTlv(data, rssize, &offset) ;
-
-	if (offset != rssize)
-		std::cerr << "RsChatDHPublicKeyItem::() Size error while deserializing." << std::endl ;
-	if (!ok)
-		std::cerr << "RsChatDHPublicKeyItem::() Unknown error while deserializing." << std::endl ;
-}
 RsChatMsgItem::RsChatMsgItem(void *data,uint32_t /*size*/,uint8_t subtype)
 	: RsChatItem(subtype)
 {

libretroshare/src/gxstunnel/p3gxstunnel.cc

@@ -585,7 +585,7 @@ bool p3GxsTunnelService::handleEncryptedData(const uint8_t *data_bytes,uint32_t
 
         // Now try deserialise the decrypted data to make an RsItem out of it.
         //
-        citem = RsGxsTunnelSerialiser().deserialiseGxsTunnelItem(decrypted_data,&decrypted_size) ;
+        citem = dynamic_cast<RsGxsTunnelItem*>(RsGxsTunnelSerialiser().deserialise(decrypted_data,&decrypted_size)) ;
         
         delete[] decrypted_data ;
 

libretroshare/src/gxstunnel/rsgxstunnelitems.h

@@ -25,6 +25,8 @@
 
 #pragma once
 
+#include <openssl/ssl.h>
+
 #include "retroshare/rstypes.h"
 #include "serialiser/rstlvkeys.h"
 #include "serialiser/rsserviceids.h"
@@ -71,8 +73,8 @@ class RsGxsTunnelItem: public RsItem
 class RsGxsTunnelDataItem: public RsGxsTunnelItem
 {
 public:
-    RsGxsTunnelDataItem() :RsGxsTunnelItem(RS_PKT_SUBTYPE_GXS_TUNNEL_DATA) {}
+    RsGxsTunnelDataItem() :RsGxsTunnelItem(RS_PKT_SUBTYPE_GXS_TUNNEL_DATA) { data=NULL ;data_size=0; }
-    RsGxsTunnelDataItem(uint8_t subtype) :RsGxsTunnelItem(subtype) {}
+    RsGxsTunnelDataItem(uint8_t subtype) :RsGxsTunnelItem(subtype) { data=NULL ;data_size=0; }
 
     virtual ~RsGxsTunnelDataItem() {}
     virtual void clear() {}
@@ -154,17 +156,22 @@ class RsGxsTunnelDHPublicKeyItem: public RsGxsTunnelItem
 
 class RsGxsTunnelSerialiser: public RsSerialType
 {
-	public:
+public:
-		RsGxsTunnelSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_TUNNEL) {}
+	RsGxsTunnelSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_TUNNEL) {}
 
-		virtual uint32_t 	size (RsItem *item) 
+	virtual uint32_t 	size (RsItem *item) 
-		{ 
+	{ 
-			return static_cast<RsGxsTunnelItem *>(item)->serial_size() ; 
+		return static_cast<RsGxsTunnelItem *>(item)->serial_size() ; 
-		}
+	}
-		virtual bool serialise(RsItem *item, void *data, uint32_t *size) 
+	virtual bool serialise(RsItem *item, void *data, uint32_t *size) 
-		{ 
+	{ 
-			return static_cast<RsGxsTunnelItem *>(item)->serialise(data,*size) ; 
+		return static_cast<RsGxsTunnelItem *>(item)->serialise(data,*size) ; 
-		}
+	}
-		virtual RsGxsTunnelItem *deserialiseGxsTunnelItem(void *data, uint32_t *size) ;
+	RsItem *deserialise(void *data, uint32_t *pktsize);
+private:
+	static RsGxsTunnelDataAckItem     *deserialise_RsGxsTunnelDataAckItem    (void *data, uint32_t size) ;
+	static RsGxsTunnelDataItem        *deserialise_RsGxsTunnelDataItem       (void *data, uint32_t size) ;
+	static RsGxsTunnelStatusItem      *deserialise_RsGxsTunnelStatusItem     (void *data, uint32_t size) ;
+	static RsGxsTunnelDHPublicKeyItem *deserialise_RsGxsTunnelDHPublicKeyItem(void *data, uint32_t size) ;
 };
 

libretroshare/src/retroshare/rsgxstunnel.h

@@ -85,8 +85,8 @@ public:
     //                  Debugging info                   //
     //===================================================//
 
-    virtual bool getGxsTunnelsInfo(std::vector<GxsTunnelInfo>& infos) =0;
+    //virtual bool getGxsTunnelsInfo(std::vector<GxsTunnelInfo>& infos) =0;
-    virtual bool getGxsTunnelInfo(const RsGxsTunnelId& tunnel_id,GxsTunnelInfo& info) =0;
+    //virtual bool getGxsTunnelInfo(const RsGxsTunnelId& tunnel_id,GxsTunnelInfo& info) =0;
 
     // retrieve the routing probabilities
 
@@ -108,7 +108,7 @@ public:
     // Data is sent through the established tunnel, possibly multiple times, until reception is acknowledged. If the tunnel does not exist, the item is rejected and 
     // an error is issued. In any case, the memory ownership of the data is *not* transferred to the tunnel service, so the client should delete it afterwards, if needed.
     
-    virtual bool sendData(const RsGxsTunnelId tunnel_id, uint32_t client_service_id, const uint8_t *data, uint32_t data_size) =0;
+    virtual bool sendData(const RsGxsTunnelId& tunnel_id, uint32_t client_service_id, const uint8_t *data, uint32_t data_size) =0;
     
     // Removes any established tunnel to this GXS id. This makes the tunnel refuse further data, but the tunnel will be however kept alive
     // until all pending data is flushed. All clients attached to the tunnel will be notified that the tunnel gets closed.

libretroshare/src/rsserver/p3face.h

@@ -39,6 +39,7 @@
 #include "util/rsthreads.h"
 
 #include "chat/p3chatservice.h"
+#include "gxstunnel/p3gxstunnel.h"
 
 #include "services/p3msgservice.h"
 #include "services/p3statusservice.h"
@@ -160,6 +161,7 @@ class RsServer: public RsControl, public RsTickingThread
 		p3MsgService  *msgSrv;
 		p3ChatService *chatSrv;
 		p3StatusService *mStatusSrv;
+		p3GxsTunnelService *mGxsTunnels;
 
         // This list contains all threaded services. It will be used to shut them down properly.
 

libretroshare/src/rsserver/rsinit.cc

@@ -1474,8 +1474,8 @@ int RsServer::StartupRetroShare()
 	pqih -> addService(tr,true);
 	pqih -> addService(ftserver,true);
 
-        p3GxsTunnelService *gxs_tunnels = new p3GxsTunnelService() ;
+        mGxsTunnels = new p3GxsTunnelService(mGxsIdService) ;
-        rsGxsTunnels = gxs_tunnels;
+        rsGxsTunnel = mGxsTunnels;
         
 	rsDisc  = mDisc;
 	rsMsgs  = new p3Msgs(msgSrv, chatSrv);
@@ -1483,7 +1483,7 @@ int RsServer::StartupRetroShare()
 	// connect components to turtle router.
 
 	ftserver->connectToTurtleRouter(tr) ;
-	chatSrv->connectToxsTunnelService(gxs_tunnels) ;
+	chatSrv->connectToGxsTunnelService(mGxsTunnels) ;
     gr->connectToTurtleRouter(tr) ;
 #ifdef ENABLE_GROUTER
 	msgSrv->connectToGlobalRouter(gr) ;