From 4f24b95b163ddc0c276c5ea308e477affbf2f54b Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 19 Mar 2017 21:28:28 +0100 Subject: [PATCH 01/94] added new serialization code test example --- .../src/serialization/serial_test.cc | 78 +++++ libretroshare/src/serialization/serializer.h | 299 ++++++++++++++++++ 2 files changed, 377 insertions(+) create mode 100644 libretroshare/src/serialization/serial_test.cc create mode 100644 libretroshare/src/serialization/serializer.h diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc new file mode 100644 index 000000000..a0409aaed --- /dev/null +++ b/libretroshare/src/serialization/serial_test.cc @@ -0,0 +1,78 @@ +// COMPILE_LINE: g++ -g serial_test.cc -I.. -o serial_test ../lib/libretroshare.a -lssl -lcrypto -lstdc++ -lpthread +// +// + +#include "serializer.h" +#include "util/rsmemory.h" +#include "util/rsprint.h" +#include "serialiser/rsserial.h" + +static const uint16_t RS_SERVICE_TYPE_TEST = 0xffff; +static const uint8_t RS_ITEM_SUBTYPE_TEST1 = 0x01 ; + +class RsTestItem: public RsSerializable +{ + public: + RsTestItem() : RsSerializable(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TEST,RS_ITEM_SUBTYPE_TEST1) {} + + virtual void serial_process(RsSerializable::SerializeJob j, SerializeContext& ctx) + { + RsTypeSerializer ().serial_process(j,ctx,ts) ; + RsTypeSerializer().serial_process(j,ctx,str) ; + } + + // derived from RsItem + // + virtual void clear() {} + virtual std::ostream& print(std::ostream&,uint16_t indent) {} + + + private: + std::string str ; + uint64_t ts ; +}; + +class RsTestSerializer: public RsSerializer +{ + public: + + virtual RsSerializable *create_item(uint16_t service,uint8_t subtype) + { + switch(subtype) + { + case RS_ITEM_SUBTYPE_TEST1: return new RsTestItem(); + + default: + return NULL ; + } + } +}; + +int main(int argc,char *argv[]) +{ + try + { + RsTestItem t1 ; + + uint32_t size = RsTestSerializer().size_item(&t1); + + std::cerr << "t1.serial_size() = " << size << std::endl; + + RsTemporaryMemory mem1(size); + + RsTestSerializer().serialize_item(&t1,mem1,mem1.size()) ; + + RsSerializable *t2 = RsTestSerializer().deserialize_item(mem1,mem1.size()) ; + + std::cerr << "Serialized t1: " << RsUtil::BinToHex(mem1,mem1.size()) << std::endl; + + return 0; + } + catch(std::exception& e) + { + std::cerr << "Exception caught: " << e.what() << std::endl; + return 1; + } +} + + diff --git a/libretroshare/src/serialization/serializer.h b/libretroshare/src/serialization/serializer.h new file mode 100644 index 000000000..65ce10269 --- /dev/null +++ b/libretroshare/src/serialization/serializer.h @@ -0,0 +1,299 @@ +#pragma once + +#include +#include +#include +#include +#include "arpa/inet.h" +#include "serialiser/rsserial.h" + +class RsItem ; + +class SerializeContext; + +class RsSerializable: public RsItem +{ +public: + typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03} SerializeJob ; + + RsSerializable(uint8_t version,uint16_t service,uint8_t id) + : RsItem(version,service,id) + { + } + + /** + * @brief serialize this object to the given buffer + * @param Job to do: serialise or deserialize. + * @param data Chunk of memory were to dump the serialized data + * @param size Size of memory chunk + * @param offset Readed to determine at witch offset start writing data, + * written to inform caller were written data ends, the updated value + * is usually passed by the caller to serialize of another + * RsSerializable so it can write on the same chunk of memory just + * after where this RsSerializable has been serialized. + * @return true if serialization successed, false otherwise + */ + + virtual void serial_process(SerializeJob j,SerializeContext& ctx) = 0; +}; + +class SerializeContext +{ + public: + + SerializeContext(uint8_t *data,uint32_t size) + : mData(data),mSize(size),mOffset(0),mOk(true) {} + + unsigned char *mData ; + uint32_t mSize ; + uint32_t mOffset ; + bool mOk ; +}; +template T ntoh(T t) +{ + if(sizeof(T) == 4) return ntohl(t) ; + if(sizeof(T) == 2) return ntohs(t) ; + + std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in ntoh<>" << std::endl; + return t; +} +template T hton(T t) +{ + if(sizeof(T) == 4) return htonl(t) ; + if(sizeof(T) == 2) return htons(t) ; + + std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in hton<>" << std::endl; + return t; +} + +template class RsTypeSerializerBase +{ + public: + void serial_process(RsSerializable::SerializeJob j,SerializeContext& ctx,T& member) + { + switch(j) + { + case RsSerializable::SIZE_ESTIMATE: ctx.mSize += serial_size(member) ; + break ; + + case RsSerializable::DESERIALIZE: deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + break ; + + case RsSerializable::SERIALIZE: serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + break ; + + default: + throw std::runtime_error("Unknown serial job") ; + } + } + + protected: + virtual bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const T& member)const=0; + virtual bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member) const=0; + virtual uint32_t serial_size(const T& /* member */)const=0; +}; + +/// Templates to generate RsSerializer for standard integral types +template class t_SerializerNType : public RsTypeSerializerBase +{ +protected: + bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const N& member)const + { + if (size <= offset || size - offset < SIZE) + return false; + + N tmp = hton(member); + memcpy(data+offset, &tmp, SIZE); + offset += SIZE; + return true; + } + bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, N& member)const + { + if (size <= offset || size - offset < SIZE) + return false; + + N tmp ; + memcpy(&tmp, data+offset, SIZE); + member = ntoh(tmp); + offset += SIZE; + return true; + } + + inline uint32_t serial_size(const N& /* member */)const + { + return SIZE; + } +}; + +template class RsTypeSerializer +{ +// public: +// virtual void serial_process(RsSerializable::SerializeJob j,SerializeContext& ctx,const T& member)=0; +// +// protected: +// virtual bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const T& member)const=0; +// virtual bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member)=0; +// virtual uint32_t serial_size(const T& /* member */)const=0; +}; + +template<> class RsTypeSerializer : public t_SerializerNType{}; +template<> class RsTypeSerializer : public t_SerializerNType{}; +template<> class RsTypeSerializer : public t_SerializerNType{}; +template<> class RsTypeSerializer : public t_SerializerNType{}; +template<> class RsTypeSerializer : public t_SerializerNType{}; + +/// Serializer for non negative float +template<> class RsTypeSerializer : public RsTypeSerializerBase +{ +protected: + bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const float& f)const + { + uint32_t sz = serial_size(f); + if ( !data || size <= offset || size - offset < sz ) + return false; + + const float tmp = f; + if(tmp < 0.0f) + { + std::cerr << "(EE) Cannot serialise invalid negative float value " + << tmp << " in " << __PRETTY_FUNCTION__ << std::endl; + return false; + } + + /* This serialisation is quite accurate. The max relative error is approx. + * 0.01% and most of the time less than 1e-05% The error is well distributed + * over numbers also. */ + uint32_t n; + if(tmp < 1e-7) n = (~(uint32_t)0); + else n = ((uint32_t)( (1.0f/(1.0f+tmp) * (~(uint32_t)0)))); + n = hton(n); + memcpy(data+offset, &n, sz); + offset += sz; + return true; + } + + bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, float& f)const + { + uint32_t sz = serial_size(f); + if ( !data || size <= offset || + size - offset < sz ) + return false; + + uint32_t n; + memcpy(&n, data+offset, sz); + n = ntoh(n); + f = 1.0f/ ( n/(float)(~(uint32_t)0)) - 1.0f; + return true; + } + inline uint32_t serial_size(const float&)const { return 4; } +}; + +/// Serializer for std::string +template<> class RsTypeSerializer : public RsTypeSerializerBase +{ + protected: + bool serialize(uint8_t data[], uint32_t size, uint32_t &offset,const std::string& s)const + { + if ( !data || size <= offset || size - offset < serial_size(s)) + return false; + + uint32_t charsLen = s.length(); + uint32_t netLen = hton(charsLen); + memcpy(data+offset, &netLen, 4); offset += 4; + memcpy(data+offset, s.c_str(), charsLen); offset += charsLen; + return true; + } + bool deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,std::string& s)const + { + if ( !data || size <= offset || size - offset < 4 ) return false; + uint32_t charsLen; + memcpy(&charsLen, data+offset, 4); offset += 4; + charsLen = ntoh(charsLen); + + if ( size <= offset || size - offset < charsLen ) return false; + s.clear(); + s.insert(0, (char*)data+offset, charsLen); + offset += charsLen; + return true; + } + inline uint32_t serial_size(const std::string& s)const + { + return s.length() + 4; + } +}; + + + +class RsSerializer +{ + public: + /*! create_item + * should be overloaded to create the correct type of item depending on the data + */ + virtual RsSerializable *create_item(uint16_t service, uint8_t item_sub_id) + { + return NULL ; + } + + RsSerializable *deserialize_item(const uint8_t *data,uint32_t size) + { + uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; + + RsSerializable *item = create_item(getRsItemService(rstype),getRsItemSubType(rstype)) ; + + if(!item) + { + std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; + return NULL ; + } + + SerializeContext ctx(const_cast(data),size); + item->serial_process(RsSerializable::DESERIALIZE, ctx) ; + + if(ctx.mOk) + return item ; + + delete item ; + return NULL ; + } + + bool serialize_item(const RsSerializable *item,uint8_t *const data,uint32_t size) + { + SerializeContext ctx(data,0); + + uint32_t tlvsize = size_item(item) ; + + if(tlvsize > size) + throw std::runtime_error("Cannot serialise: not enough room.") ; + + if(!setRsItemHeader(data, tlvsize, const_cast(item)->PacketId(), tlvsize)) + { + std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; + return false ; + } + ctx.mOffset = 8; + ctx.mSize = tlvsize; + + const_cast(item)->serial_process(RsSerializable::SERIALIZE,ctx) ; + + if(ctx.mSize != ctx.mOffset) + { + std::cerr << "RsSerializer::serialise_item(): ERROR. offset does not match expected size!" << std::endl; + return false ; + } + return true ; + } + + uint32_t size_item(const RsSerializable *item) + { + SerializeContext ctx(NULL,0); + + ctx.mSize = 8 ; // header size + const_cast(item)->serial_process(RsSerializable::SIZE_ESTIMATE, ctx) ; + + return ctx.mSize ; + } +}; + + + From 369621f4a40c77aae7fb0d1aed2e30ada0b6dad1 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 20 Mar 2017 23:31:04 +0100 Subject: [PATCH 02/94] simplified new serialization prototype --- .../src/serialization/serial_test.cc | 74 ++++++++++- libretroshare/src/serialization/serializer.h | 117 +++++++++++------- 2 files changed, 144 insertions(+), 47 deletions(-) diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc index a0409aaed..08c53b6db 100644 --- a/libretroshare/src/serialization/serial_test.cc +++ b/libretroshare/src/serialization/serial_test.cc @@ -2,6 +2,8 @@ // // +#include + #include "serializer.h" #include "util/rsmemory.h" #include "util/rsprint.h" @@ -10,18 +12,79 @@ static const uint16_t RS_SERVICE_TYPE_TEST = 0xffff; static const uint8_t RS_ITEM_SUBTYPE_TEST1 = 0x01 ; +// Template serialization of RsTypeSerialiser::serial_process() for unknown/new types +// +// +template<> uint32_t RsTypeSerializer::serial_size(const std::set& s) +{ + return s.size() * 4 + 4 ; +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const std::set& member) +{ + uint32_t tlvsize = serial_size(member) ; + bool ok = true ; + uint32_t offset_save = offset ; + + if(tlvsize + offset >= size) + return false ; + + ok = ok && RsTypeSerializer::serialize(data,size,offset,member.size()) ; + + for(std::set::const_iterator it(member.begin());it!=member.end();++it) + ok = ok && RsTypeSerializer::serialize(data,size,offset,*it) ; + + if(!ok) + { + std::cerr << "(EE) Cannot serialize std::set" << std::endl; + offset = offset_save ; // return the data in the same condition + } + return ok ; +} + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, std::set& member) +{ + bool ok = true ; + uint32_t n = 0 ; + uint32_t offset_save = offset ; + member.clear(); + + ok = ok && RsTypeSerializer::deserialize(data,size,offset,n); + + for(uint32_t i=0;i" << std::endl; + offset = offset_save ; // return the data in the same condition + } + return ok; +} + +// New item class. This class needs to define: +// - a serial_process method that tells which members to serialize +// - overload the clear() and print() methods of RsItem +// class RsTestItem: public RsSerializable { public: RsTestItem() : RsSerializable(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TEST,RS_ITEM_SUBTYPE_TEST1) {} + // Derived from RsSerializable + // virtual void serial_process(RsSerializable::SerializeJob j, SerializeContext& ctx) { - RsTypeSerializer ().serial_process(j,ctx,ts) ; - RsTypeSerializer().serial_process(j,ctx,str) ; + RsTypeSerializer::serial_process(j,ctx,ts ) ; + RsTypeSerializer::serial_process(j,ctx,str) ; + RsTypeSerializer::serial_process(j,ctx,int_set ) ; } - // derived from RsItem + // Derived from RsItem // virtual void clear() {} virtual std::ostream& print(std::ostream&,uint16_t indent) {} @@ -30,8 +93,13 @@ class RsTestItem: public RsSerializable private: std::string str ; uint64_t ts ; + std::set int_set ; }; +// New user-defined serializer class. +// The only required member is the create_item() method, which creates the correct RsSerializable +// that corresponds to a specific (service,subtype) couple. +// class RsTestSerializer: public RsSerializer { public: diff --git a/libretroshare/src/serialization/serializer.h b/libretroshare/src/serialization/serializer.h index 65ce10269..462206c42 100644 --- a/libretroshare/src/serialization/serializer.h +++ b/libretroshare/src/serialization/serializer.h @@ -51,6 +51,7 @@ class SerializeContext }; template T ntoh(T t) { + if(sizeof(T) == 8) return t; if(sizeof(T) == 4) return ntohl(t) ; if(sizeof(T) == 2) return ntohs(t) ; @@ -59,6 +60,7 @@ template T ntoh(T t) } template T hton(T t) { + if(sizeof(T) == 8) return t; if(sizeof(T) == 4) return htonl(t) ; if(sizeof(T) == 2) return htons(t) ; @@ -66,10 +68,11 @@ template T hton(T t) return t; } -template class RsTypeSerializerBase +class RsTypeSerializer { public: - void serial_process(RsSerializable::SerializeJob j,SerializeContext& ctx,T& member) + template + static void serial_process(RsSerializable::SerializeJob j,SerializeContext& ctx,T& member) { switch(j) { @@ -88,16 +91,22 @@ template class RsTypeSerializerBase } protected: - virtual bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const T& member)const=0; - virtual bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member) const=0; - virtual uint32_t serial_size(const T& /* member */)const=0; + template + static bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const T& member); + + template + static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); + + template + static uint32_t serial_size(const T& /* member */); }; /// Templates to generate RsSerializer for standard integral types -template class t_SerializerNType : public RsTypeSerializerBase +// +template class t_SerializerNType { -protected: - bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const N& member)const +public: + static bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const N& member) { if (size <= offset || size - offset < SIZE) return false; @@ -107,7 +116,7 @@ protected: offset += SIZE; return true; } - bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, N& member)const + static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, N& member) { if (size <= offset || size - offset < SIZE) return false; @@ -119,34 +128,56 @@ protected: return true; } - inline uint32_t serial_size(const N& /* member */)const + static uint32_t serial_size(const N& /* member */) { return SIZE; } }; -template class RsTypeSerializer -{ -// public: -// virtual void serial_process(RsSerializable::SerializeJob j,SerializeContext& ctx,const T& member)=0; +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint8_t& member) +{ + return t_SerializerNType::serialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint32_t& member) +{ + return t_SerializerNType::serialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint64_t& member) +{ + return t_SerializerNType::serialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint8_t& member) +{ + return t_SerializerNType::deserialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint32_t& member) +{ + return t_SerializerNType::deserialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint64_t& member) +{ + return t_SerializerNType::deserialize(data,size,offset,member); +} +template<> uint32_t RsTypeSerializer::serial_size(const uint8_t& member) +{ + return t_SerializerNType::serial_size(member); +} +template<> uint32_t RsTypeSerializer::serial_size(const uint32_t& member) +{ + return t_SerializerNType::serial_size(member); +} +template<> uint32_t RsTypeSerializer::serial_size(const uint64_t& member) +{ + return t_SerializerNType::serial_size(member); +} +//// Float // -// protected: -// virtual bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const T& member)const=0; -// virtual bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member)=0; -// virtual uint32_t serial_size(const T& /* member */)const=0; -}; +template<> + uint32_t RsTypeSerializer::serial_size(const float&){ return 4; } -template<> class RsTypeSerializer : public t_SerializerNType{}; -template<> class RsTypeSerializer : public t_SerializerNType{}; -template<> class RsTypeSerializer : public t_SerializerNType{}; -template<> class RsTypeSerializer : public t_SerializerNType{}; -template<> class RsTypeSerializer : public t_SerializerNType{}; -/// Serializer for non negative float -template<> class RsTypeSerializer : public RsTypeSerializerBase -{ -protected: - bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const float& f)const +template<> +bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const float& f) { uint32_t sz = serial_size(f); if ( !data || size <= offset || size - offset < sz ) @@ -172,7 +203,14 @@ protected: return true; } - bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, float& f)const +template<> uint32_t RsTypeSerializer::serial_size(const std::string& s) +{ + return s.length() + 4; +} + + +template<> + bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, float& f) { uint32_t sz = serial_size(f); if ( !data || size <= offset || @@ -185,14 +223,11 @@ protected: f = 1.0f/ ( n/(float)(~(uint32_t)0)) - 1.0f; return true; } - inline uint32_t serial_size(const float&)const { return 4; } -}; + /// Serializer for std::string -template<> class RsTypeSerializer : public RsTypeSerializerBase -{ - protected: - bool serialize(uint8_t data[], uint32_t size, uint32_t &offset,const std::string& s)const + template<> + bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const std::string& s) { if ( !data || size <= offset || size - offset < serial_size(s)) return false; @@ -203,7 +238,8 @@ template<> class RsTypeSerializer : public RsTypeSerializerBase + bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,std::string& s) { if ( !data || size <= offset || size - offset < 4 ) return false; uint32_t charsLen; @@ -216,13 +252,6 @@ template<> class RsTypeSerializer : public RsTypeSerializerBase Date: Sat, 25 Mar 2017 19:01:32 +0100 Subject: [PATCH 03/94] polished serialisation prototype --- .../src/serialization/rsserializable.h | 35 ++ .../src/serialization/rsserializer.h | 97 ++++++ .../src/serialization/rstypeserializer.h | 195 +++++++++++ .../src/serialization/serial_test.cc | 54 ++- libretroshare/src/serialization/serializer.h | 328 ------------------ 5 files changed, 371 insertions(+), 338 deletions(-) create mode 100644 libretroshare/src/serialization/rsserializable.h create mode 100644 libretroshare/src/serialization/rsserializer.h create mode 100644 libretroshare/src/serialization/rstypeserializer.h delete mode 100644 libretroshare/src/serialization/serializer.h diff --git a/libretroshare/src/serialization/rsserializable.h b/libretroshare/src/serialization/rsserializable.h new file mode 100644 index 000000000..3351e0147 --- /dev/null +++ b/libretroshare/src/serialization/rsserializable.h @@ -0,0 +1,35 @@ +#pragma once + +#include "serialiser/rsserial.h" + +class RsItem ; +class SerializeContext; + +#define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " + +class RsSerializable: public RsItem +{ +public: + typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03} SerializeJob ; + + RsSerializable(uint8_t version,uint16_t service,uint8_t id) + : RsItem(version,service,id) + { + } + + /** + * @brief serialize this object to the given buffer + * @param Job to do: serialise or deserialize. + * @param data Chunk of memory were to dump the serialized data + * @param size Size of memory chunk + * @param offset Readed to determine at witch offset start writing data, + * written to inform caller were written data ends, the updated value + * is usually passed by the caller to serialize of another + * RsSerializable so it can write on the same chunk of memory just + * after where this RsSerializable has been serialized. + * @return true if serialization successed, false otherwise + */ + + virtual void serial_process(SerializeJob j,SerializeContext& ctx) = 0; +}; + diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h new file mode 100644 index 000000000..706ee3be4 --- /dev/null +++ b/libretroshare/src/serialization/rsserializer.h @@ -0,0 +1,97 @@ +#pragma once + +#include +#include +#include +#include + +#include "rsserializable.h" + +class SerializeContext +{ + public: + + SerializeContext(uint8_t *data,uint32_t size) + : mData(data),mSize(size),mOffset(0),mOk(true) {} + + unsigned char *mData ; + uint32_t mSize ; + uint32_t mOffset ; + bool mOk ; +}; + +class RsSerializer +{ + public: + /*! create_item + * should be overloaded to create the correct type of item depending on the data + */ + virtual RsSerializable *create_item(uint16_t service, uint8_t item_sub_id) + { + return NULL ; + } + + RsSerializable *deserialize_item(const uint8_t *data,uint32_t size) + { + uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; + + RsSerializable *item = create_item(getRsItemService(rstype),getRsItemSubType(rstype)) ; + + if(!item) + { + std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; + return NULL ; + } + + SerializeContext ctx(const_cast(data),size); + ctx.mOffset = 8 ; + + item->serial_process(RsSerializable::DESERIALIZE, ctx) ; + + if(ctx.mOk) + return item ; + + delete item ; + return NULL ; + } + + bool serialize_item(const RsSerializable *item,uint8_t *const data,uint32_t size) + { + SerializeContext ctx(data,0); + + uint32_t tlvsize = size_item(item) ; + + if(tlvsize > size) + throw std::runtime_error("Cannot serialise: not enough room.") ; + + if(!setRsItemHeader(data, tlvsize, const_cast(item)->PacketId(), tlvsize)) + { + std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; + return false ; + } + ctx.mOffset = 8; + ctx.mSize = tlvsize; + + const_cast(item)->serial_process(RsSerializable::SERIALIZE,ctx) ; + + if(ctx.mSize != ctx.mOffset) + { + std::cerr << "RsSerializer::serialise_item(): ERROR. offset does not match expected size!" << std::endl; + return false ; + } + return true ; + } + + uint32_t size_item(const RsSerializable *item) + { + SerializeContext ctx(NULL,0); + + ctx.mSize = 8 ; // header size + const_cast(item)->serial_process(RsSerializable::SIZE_ESTIMATE, ctx) ; + + return ctx.mSize ; + } +}; + + + diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h new file mode 100644 index 000000000..a713832b3 --- /dev/null +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -0,0 +1,195 @@ +#include "serialiser/rstlvbase.h" + +template T ntoh(T t) +{ + if(sizeof(T) == 8) return t; + if(sizeof(T) == 4) return ntohl(t) ; + if(sizeof(T) == 2) return ntohs(t) ; + + std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in ntoh<>" << std::endl; + return t; +} +template T hton(T t) +{ + if(sizeof(T) == 8) return t; + if(sizeof(T) == 4) return htonl(t) ; + if(sizeof(T) == 2) return htons(t) ; + + std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in hton<>" << std::endl; + return t; +} + +class RsTypeSerializer +{ + public: + template + static void serial_process(RsSerializable::SerializeJob j,SerializeContext& ctx,T& member) + { + switch(j) + { + case RsSerializable::SIZE_ESTIMATE: ctx.mSize += serial_size(member) ; + break ; + + case RsSerializable::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + break ; + + case RsSerializable::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + break ; + + default: + ctx.mOk = false ; + throw std::runtime_error("Unknown serial job") ; + } + } + + protected: + template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member); + template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); + template static uint32_t serial_size(const T& /* member */); +}; + +/// Templates to generate RsSerializer for standard integral types +// +template class t_SerializerNType +{ +public: + static bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const N& member) + { + if (size <= offset || size < SIZE + offset) + { + SERIALIZE_ERROR() << ": not enough room. SIZE+offset=" << SIZE+offset << " and size is only " << size << std::endl; + return false; + } + + N tmp = hton(member); + memcpy(data+offset, &tmp, SIZE); + offset += SIZE; + return true; + } + static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, N& member) + { + if (size <= offset || size < offset + SIZE) + { + SERIALIZE_ERROR() << ": not enough room. SIZE+offset=" << SIZE+offset << " and size is only " << size << std::endl; + return false; + } + + N tmp ; + memcpy(&tmp, data+offset, SIZE); + member = ntoh(tmp); + offset += SIZE; + return true; + } + + static uint32_t serial_size(const N& /* member */) + { + return SIZE; + } +}; + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint8_t& member) +{ + return t_SerializerNType::serialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint32_t& member) +{ + return t_SerializerNType::serialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint64_t& member) +{ + return t_SerializerNType::serialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint8_t& member) +{ + return t_SerializerNType::deserialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint32_t& member) +{ + return t_SerializerNType::deserialize(data,size,offset,member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint64_t& member) +{ + return t_SerializerNType::deserialize(data,size,offset,member); +} +template<> uint32_t RsTypeSerializer::serial_size(const uint8_t& member) +{ + return t_SerializerNType::serial_size(member); +} +template<> uint32_t RsTypeSerializer::serial_size(const uint32_t& member) +{ + return t_SerializerNType::serial_size(member); +} +template<> uint32_t RsTypeSerializer::serial_size(const uint64_t& member) +{ + return t_SerializerNType::serial_size(member); +} +//// Float +// +template<> uint32_t RsTypeSerializer::serial_size(const float&){ return 4; } + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t& offset, const float& f) +{ + uint32_t sz = serial_size(f); + + if ( !data || size <= offset || size < sz + offset ) + { + SERIALIZE_ERROR() << ": not enough room. SIZE+offset=" << sz+offset << " and size is only " << size << std::endl; + return false; + } + + const float tmp = f; + if(tmp < 0.0f) + { + SERIALIZE_ERROR() << "Cannot serialise invalid negative float value " << tmp << std::endl; + return false; + } + + /* This serialisation is quite accurate. The max relative error is approx. + * 0.01% and most of the time less than 1e-05% The error is well distributed + * over numbers also. */ + + uint32_t n; + if(tmp < 1e-7) n = (~(uint32_t)0); + else n = ((uint32_t)( (1.0f/(1.0f+tmp) * (~(uint32_t)0)))); + n = hton(n); + memcpy(data+offset, &n, sz); + offset += sz; + return true; +} + + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, float& f) +{ + uint32_t sz = serial_size(f); + + if ( !data || size <= offset || size < offset + sz ) + { + SERIALIZE_ERROR() << "Cannot deserialise float value. Not enough room. size=" << size << ", offset=" << offset << std::endl; + return false; + } + + uint32_t n; + memcpy(&n, data+offset, sz); + n = ntoh(n); + f = 1.0f/ ( n/(float)(~(uint32_t)0)) - 1.0f; + return true; +} + +typedef std::pair TlvString; + +/// Serializer for std::string +template<> uint32_t RsTypeSerializer::serial_size(const TlvString& s) +{ + return GetTlvStringSize(s.first) ; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const TlvString& s) +{ + return SetTlvString(data,size,&offset,s.second,s.first) ; +} + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,TlvString& s) +{ + return GetTlvString((void*)data,size,&offset,s.second,s.first) ; +} + diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc index 08c53b6db..9b5745b4b 100644 --- a/libretroshare/src/serialization/serial_test.cc +++ b/libretroshare/src/serialization/serial_test.cc @@ -4,16 +4,18 @@ #include -#include "serializer.h" #include "util/rsmemory.h" #include "util/rsprint.h" #include "serialiser/rsserial.h" +#include "serializer.h" +#include "rstypeserializer.h" + static const uint16_t RS_SERVICE_TYPE_TEST = 0xffff; static const uint8_t RS_ITEM_SUBTYPE_TEST1 = 0x01 ; // Template serialization of RsTypeSerialiser::serial_process() for unknown/new types -// +// Here we do it for std::set as an example. // template<> uint32_t RsTypeSerializer::serial_size(const std::set& s) { @@ -25,13 +27,16 @@ template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint3 bool ok = true ; uint32_t offset_save = offset ; - if(tlvsize + offset >= size) + if(tlvsize + offset > size) + { + std::cerr << "RsTypeSerializer::serialize: error. tlvsize+offset > size, where tlvsize=" << tlvsize << ", offset=" << offset << ", size=" << size << std::endl; return false ; + } - ok = ok && RsTypeSerializer::serialize(data,size,offset,member.size()) ; + ok = ok && RsTypeSerializer::serialize(data,size,offset,member.size()) ; for(std::set::const_iterator it(member.begin());it!=member.end();++it) - ok = ok && RsTypeSerializer::serialize(data,size,offset,*it) ; + ok = ok && RsTypeSerializer::serialize(data,size,offset,*it) ; if(!ok) { @@ -50,7 +55,7 @@ template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t siz ok = ok && RsTypeSerializer::deserialize(data,size,offset,n); - for(uint32_t i=0;i bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t siz class RsTestItem: public RsSerializable { public: - RsTestItem() : RsSerializable(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TEST,RS_ITEM_SUBTYPE_TEST1) {} + RsTestItem() : RsSerializable(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TEST,RS_ITEM_SUBTYPE_TEST1) + { + str = "test string"; + ts = time(NULL) ; + + int_set.insert(lrand48()) ; + int_set.insert(lrand48()) ; + int_set.insert(lrand48()) ; + } // Derived from RsSerializable // virtual void serial_process(RsSerializable::SerializeJob j, SerializeContext& ctx) { + TlvString tt(str,TLV_TYPE_STR_DESCR) ; + RsTypeSerializer::serial_process(j,ctx,ts ) ; - RsTypeSerializer::serial_process(j,ctx,str) ; + RsTypeSerializer::serial_process(j,ctx,tt ) ; RsTypeSerializer::serial_process(j,ctx,int_set ) ; } @@ -89,11 +104,12 @@ class RsTestItem: public RsSerializable virtual void clear() {} virtual std::ostream& print(std::ostream&,uint16_t indent) {} - private: std::string str ; uint64_t ts ; std::set int_set ; + + friend int main(int argc,char *argv[]); }; // New user-defined serializer class. @@ -116,6 +132,12 @@ class RsTestSerializer: public RsSerializer } }; +// Methods to check the equality of items. +// +void check(const std::string& s1,const std::string& s2) { assert(s1 == s2) ; } +void check(const uint64_t& s1,const uint64_t& s2) { assert(s1 == s2) ; } +void check(const std::set& s1,const std::set& s2) { assert(s1 == s2) ; } + int main(int argc,char *argv[]) { try @@ -126,13 +148,25 @@ int main(int argc,char *argv[]) std::cerr << "t1.serial_size() = " << size << std::endl; + // Allocate some memory to serialise to + // RsTemporaryMemory mem1(size); RsTestSerializer().serialize_item(&t1,mem1,mem1.size()) ; + std::cerr << "Serialized t1: " << RsUtil::BinToHex(mem1,mem1.size()) << std::endl; + + // Now deserialise into a new item + // RsSerializable *t2 = RsTestSerializer().deserialize_item(mem1,mem1.size()) ; - std::cerr << "Serialized t1: " << RsUtil::BinToHex(mem1,mem1.size()) << std::endl; + // make sure t1 is equal to t2 + // + check(t1.str,dynamic_cast(t2)->str) ; + check(t1.ts,dynamic_cast(t2)->ts) ; + check(t1.int_set,dynamic_cast(t2)->int_set) ; + + delete t2; return 0; } diff --git a/libretroshare/src/serialization/serializer.h b/libretroshare/src/serialization/serializer.h deleted file mode 100644 index 462206c42..000000000 --- a/libretroshare/src/serialization/serializer.h +++ /dev/null @@ -1,328 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include "arpa/inet.h" -#include "serialiser/rsserial.h" - -class RsItem ; - -class SerializeContext; - -class RsSerializable: public RsItem -{ -public: - typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03} SerializeJob ; - - RsSerializable(uint8_t version,uint16_t service,uint8_t id) - : RsItem(version,service,id) - { - } - - /** - * @brief serialize this object to the given buffer - * @param Job to do: serialise or deserialize. - * @param data Chunk of memory were to dump the serialized data - * @param size Size of memory chunk - * @param offset Readed to determine at witch offset start writing data, - * written to inform caller were written data ends, the updated value - * is usually passed by the caller to serialize of another - * RsSerializable so it can write on the same chunk of memory just - * after where this RsSerializable has been serialized. - * @return true if serialization successed, false otherwise - */ - - virtual void serial_process(SerializeJob j,SerializeContext& ctx) = 0; -}; - -class SerializeContext -{ - public: - - SerializeContext(uint8_t *data,uint32_t size) - : mData(data),mSize(size),mOffset(0),mOk(true) {} - - unsigned char *mData ; - uint32_t mSize ; - uint32_t mOffset ; - bool mOk ; -}; -template T ntoh(T t) -{ - if(sizeof(T) == 8) return t; - if(sizeof(T) == 4) return ntohl(t) ; - if(sizeof(T) == 2) return ntohs(t) ; - - std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in ntoh<>" << std::endl; - return t; -} -template T hton(T t) -{ - if(sizeof(T) == 8) return t; - if(sizeof(T) == 4) return htonl(t) ; - if(sizeof(T) == 2) return htons(t) ; - - std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in hton<>" << std::endl; - return t; -} - -class RsTypeSerializer -{ - public: - template - static void serial_process(RsSerializable::SerializeJob j,SerializeContext& ctx,T& member) - { - switch(j) - { - case RsSerializable::SIZE_ESTIMATE: ctx.mSize += serial_size(member) ; - break ; - - case RsSerializable::DESERIALIZE: deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; - break ; - - case RsSerializable::SERIALIZE: serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; - break ; - - default: - throw std::runtime_error("Unknown serial job") ; - } - } - - protected: - template - static bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const T& member); - - template - static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); - - template - static uint32_t serial_size(const T& /* member */); -}; - -/// Templates to generate RsSerializer for standard integral types -// -template class t_SerializerNType -{ -public: - static bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const N& member) - { - if (size <= offset || size - offset < SIZE) - return false; - - N tmp = hton(member); - memcpy(data+offset, &tmp, SIZE); - offset += SIZE; - return true; - } - static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, N& member) - { - if (size <= offset || size - offset < SIZE) - return false; - - N tmp ; - memcpy(&tmp, data+offset, SIZE); - member = ntoh(tmp); - offset += SIZE; - return true; - } - - static uint32_t serial_size(const N& /* member */) - { - return SIZE; - } -}; - -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint8_t& member) -{ - return t_SerializerNType::serialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint32_t& member) -{ - return t_SerializerNType::serialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint64_t& member) -{ - return t_SerializerNType::serialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint8_t& member) -{ - return t_SerializerNType::deserialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint32_t& member) -{ - return t_SerializerNType::deserialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint64_t& member) -{ - return t_SerializerNType::deserialize(data,size,offset,member); -} -template<> uint32_t RsTypeSerializer::serial_size(const uint8_t& member) -{ - return t_SerializerNType::serial_size(member); -} -template<> uint32_t RsTypeSerializer::serial_size(const uint32_t& member) -{ - return t_SerializerNType::serial_size(member); -} -template<> uint32_t RsTypeSerializer::serial_size(const uint64_t& member) -{ - return t_SerializerNType::serial_size(member); -} -//// Float -// -template<> - uint32_t RsTypeSerializer::serial_size(const float&){ return 4; } - - -template<> -bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const float& f) - { - uint32_t sz = serial_size(f); - if ( !data || size <= offset || size - offset < sz ) - return false; - - const float tmp = f; - if(tmp < 0.0f) - { - std::cerr << "(EE) Cannot serialise invalid negative float value " - << tmp << " in " << __PRETTY_FUNCTION__ << std::endl; - return false; - } - - /* This serialisation is quite accurate. The max relative error is approx. - * 0.01% and most of the time less than 1e-05% The error is well distributed - * over numbers also. */ - uint32_t n; - if(tmp < 1e-7) n = (~(uint32_t)0); - else n = ((uint32_t)( (1.0f/(1.0f+tmp) * (~(uint32_t)0)))); - n = hton(n); - memcpy(data+offset, &n, sz); - offset += sz; - return true; - } - -template<> uint32_t RsTypeSerializer::serial_size(const std::string& s) -{ - return s.length() + 4; -} - - -template<> - bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, float& f) - { - uint32_t sz = serial_size(f); - if ( !data || size <= offset || - size - offset < sz ) - return false; - - uint32_t n; - memcpy(&n, data+offset, sz); - n = ntoh(n); - f = 1.0f/ ( n/(float)(~(uint32_t)0)) - 1.0f; - return true; - } - - -/// Serializer for std::string - template<> - bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const std::string& s) - { - if ( !data || size <= offset || size - offset < serial_size(s)) - return false; - - uint32_t charsLen = s.length(); - uint32_t netLen = hton(charsLen); - memcpy(data+offset, &netLen, 4); offset += 4; - memcpy(data+offset, s.c_str(), charsLen); offset += charsLen; - return true; - } -template<> - bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,std::string& s) - { - if ( !data || size <= offset || size - offset < 4 ) return false; - uint32_t charsLen; - memcpy(&charsLen, data+offset, 4); offset += 4; - charsLen = ntoh(charsLen); - - if ( size <= offset || size - offset < charsLen ) return false; - s.clear(); - s.insert(0, (char*)data+offset, charsLen); - offset += charsLen; - return true; - } - -class RsSerializer -{ - public: - /*! create_item - * should be overloaded to create the correct type of item depending on the data - */ - virtual RsSerializable *create_item(uint16_t service, uint8_t item_sub_id) - { - return NULL ; - } - - RsSerializable *deserialize_item(const uint8_t *data,uint32_t size) - { - uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; - - RsSerializable *item = create_item(getRsItemService(rstype),getRsItemSubType(rstype)) ; - - if(!item) - { - std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; - return NULL ; - } - - SerializeContext ctx(const_cast(data),size); - item->serial_process(RsSerializable::DESERIALIZE, ctx) ; - - if(ctx.mOk) - return item ; - - delete item ; - return NULL ; - } - - bool serialize_item(const RsSerializable *item,uint8_t *const data,uint32_t size) - { - SerializeContext ctx(data,0); - - uint32_t tlvsize = size_item(item) ; - - if(tlvsize > size) - throw std::runtime_error("Cannot serialise: not enough room.") ; - - if(!setRsItemHeader(data, tlvsize, const_cast(item)->PacketId(), tlvsize)) - { - std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; - return false ; - } - ctx.mOffset = 8; - ctx.mSize = tlvsize; - - const_cast(item)->serial_process(RsSerializable::SERIALIZE,ctx) ; - - if(ctx.mSize != ctx.mOffset) - { - std::cerr << "RsSerializer::serialise_item(): ERROR. offset does not match expected size!" << std::endl; - return false ; - } - return true ; - } - - uint32_t size_item(const RsSerializable *item) - { - SerializeContext ctx(NULL,0); - - ctx.mSize = 8 ; // header size - const_cast(item)->serial_process(RsSerializable::SIZE_ESTIMATE, ctx) ; - - return ctx.mSize ; - } -}; - - - From b52071d0c9e63477e2a60a701a6a73c235d74bf4 Mon Sep 17 00:00:00 2001 From: csoler Date: Sat, 1 Apr 2017 18:05:53 +0200 Subject: [PATCH 04/94] removed RsSerializable and merged it into RsItem --- libretroshare/src/serialiser/rsserial.h | 19 ++++++++++++- .../src/serialization/rsserializer.h | 28 +++++++++++-------- .../src/serialization/rstypeserializer.h | 8 +++--- .../src/serialization/serial_test.cc | 21 +++++++------- 4 files changed, 49 insertions(+), 27 deletions(-) diff --git a/libretroshare/src/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index bb8b84d8c..ad735abe5 100644 --- a/libretroshare/src/serialiser/rsserial.h +++ b/libretroshare/src/serialiser/rsserial.h @@ -70,6 +70,7 @@ const uint8_t RS_PKT_CLASS_CONFIG = 0x02; const uint8_t RS_PKT_SUBTYPE_DEFAULT = 0x01; /* if only one subtype */ +class SerializeContext ; class RsItem: public RsMemoryManagement::SmallObject { @@ -105,7 +106,23 @@ class RsItem: public RsMemoryManagement::SmallObject void setPacketService(uint16_t service); inline uint8_t priority_level() const { return _priority_level ;} - inline void setPriorityLevel(uint8_t l) { _priority_level = l ;} + inline void setPriorityLevel(uint8_t l) { _priority_level = l ;} + + /** + * @brief serialize this object to the given buffer + * @param Job to do: serialise or deserialize. + * @param data Chunk of memory were to dump the serialized data + * @param size Size of memory chunk + * @param offset Readed to determine at witch offset start writing data, + * written to inform caller were written data ends, the updated value + * is usually passed by the caller to serialize of another + * RsSerializable so it can write on the same chunk of memory just + * after where this RsSerializable has been serialized. + * @return true if serialization successed, false otherwise + */ + typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03} SerializeJob ; + + virtual void serial_process(SerializeJob j,SerializeContext& ctx) = 0; private: uint32_t type; diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 706ee3be4..e7725b955 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -5,7 +5,9 @@ #include #include -#include "rsserializable.h" +#include "serialiser/rsserial.h" + +#define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " class SerializeContext { @@ -20,22 +22,24 @@ class SerializeContext bool mOk ; }; -class RsSerializer +class RsSerializer: public RsSerialType { public: + RsSerializer(uint16_t service_id) : RsSerialType(service_id) {} + /*! create_item * should be overloaded to create the correct type of item depending on the data */ - virtual RsSerializable *create_item(uint16_t service, uint8_t item_sub_id) + virtual RsItem *create_item(uint16_t service, uint8_t item_sub_id) { return NULL ; } - RsSerializable *deserialize_item(const uint8_t *data,uint32_t size) + RsItem *deserialise(const uint8_t *data,uint32_t size) { uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; - RsSerializable *item = create_item(getRsItemService(rstype),getRsItemSubType(rstype)) ; + RsItem *item = create_item(getRsItemService(rstype),getRsItemSubType(rstype)) ; if(!item) { @@ -46,7 +50,7 @@ class RsSerializer SerializeContext ctx(const_cast(data),size); ctx.mOffset = 8 ; - item->serial_process(RsSerializable::DESERIALIZE, ctx) ; + item->serial_process(RsItem::DESERIALIZE, ctx) ; if(ctx.mOk) return item ; @@ -55,16 +59,16 @@ class RsSerializer return NULL ; } - bool serialize_item(const RsSerializable *item,uint8_t *const data,uint32_t size) + bool serialise(RsItem *item,uint8_t *const data,uint32_t size) { SerializeContext ctx(data,0); - uint32_t tlvsize = size_item(item) ; + uint32_t tlvsize = this->size(item) ; if(tlvsize > size) throw std::runtime_error("Cannot serialise: not enough room.") ; - if(!setRsItemHeader(data, tlvsize, const_cast(item)->PacketId(), tlvsize)) + if(!setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize)) { std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; return false ; @@ -72,7 +76,7 @@ class RsSerializer ctx.mOffset = 8; ctx.mSize = tlvsize; - const_cast(item)->serial_process(RsSerializable::SERIALIZE,ctx) ; + item->serial_process(RsItem::SERIALIZE,ctx) ; if(ctx.mSize != ctx.mOffset) { @@ -82,12 +86,12 @@ class RsSerializer return true ; } - uint32_t size_item(const RsSerializable *item) + uint32_t size(RsItem *item) { SerializeContext ctx(NULL,0); ctx.mSize = 8 ; // header size - const_cast(item)->serial_process(RsSerializable::SIZE_ESTIMATE, ctx) ; + item->serial_process(RsItem::SIZE_ESTIMATE, ctx) ; return ctx.mSize ; } diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index a713832b3..4661ecc61 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -23,17 +23,17 @@ class RsTypeSerializer { public: template - static void serial_process(RsSerializable::SerializeJob j,SerializeContext& ctx,T& member) + static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member) { switch(j) { - case RsSerializable::SIZE_ESTIMATE: ctx.mSize += serial_size(member) ; + case RsItem::SIZE_ESTIMATE: ctx.mSize += serial_size(member) ; break ; - case RsSerializable::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + case RsItem::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; break ; - case RsSerializable::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + case RsItem::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; break ; default: diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc index 9b5745b4b..f1698ad0c 100644 --- a/libretroshare/src/serialization/serial_test.cc +++ b/libretroshare/src/serialization/serial_test.cc @@ -8,7 +8,7 @@ #include "util/rsprint.h" #include "serialiser/rsserial.h" -#include "serializer.h" +#include "rsserializer.h" #include "rstypeserializer.h" static const uint16_t RS_SERVICE_TYPE_TEST = 0xffff; @@ -75,10 +75,10 @@ template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t siz // - a serial_process method that tells which members to serialize // - overload the clear() and print() methods of RsItem // -class RsTestItem: public RsSerializable +class RsTestItem: public RsItem { public: - RsTestItem() : RsSerializable(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TEST,RS_ITEM_SUBTYPE_TEST1) + RsTestItem() : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TEST,RS_ITEM_SUBTYPE_TEST1) { str = "test string"; ts = time(NULL) ; @@ -88,9 +88,9 @@ class RsTestItem: public RsSerializable int_set.insert(lrand48()) ; } - // Derived from RsSerializable + // Derived from RsItem // - virtual void serial_process(RsSerializable::SerializeJob j, SerializeContext& ctx) + virtual void serial_process(RsItem::SerializeJob j, SerializeContext& ctx) { TlvString tt(str,TLV_TYPE_STR_DESCR) ; @@ -113,14 +113,15 @@ class RsTestItem: public RsSerializable }; // New user-defined serializer class. -// The only required member is the create_item() method, which creates the correct RsSerializable +// The only required member is the create_item() method, which creates the correct RsItem // that corresponds to a specific (service,subtype) couple. // class RsTestSerializer: public RsSerializer { public: + RsTestSerializer() : RsSerializer(RS_SERVICE_TYPE_TEST) {} - virtual RsSerializable *create_item(uint16_t service,uint8_t subtype) + virtual RsItem *create_item(uint8_t subtype) { switch(subtype) { @@ -144,7 +145,7 @@ int main(int argc,char *argv[]) { RsTestItem t1 ; - uint32_t size = RsTestSerializer().size_item(&t1); + uint32_t size = RsTestSerializer().size(&t1); std::cerr << "t1.serial_size() = " << size << std::endl; @@ -152,13 +153,13 @@ int main(int argc,char *argv[]) // RsTemporaryMemory mem1(size); - RsTestSerializer().serialize_item(&t1,mem1,mem1.size()) ; + RsTestSerializer().serialise(&t1,mem1,mem1.size()) ; std::cerr << "Serialized t1: " << RsUtil::BinToHex(mem1,mem1.size()) << std::endl; // Now deserialise into a new item // - RsSerializable *t2 = RsTestSerializer().deserialize_item(mem1,mem1.size()) ; + RsItem *t2 = RsTestSerializer().deserialise(mem1,mem1.size()) ; // make sure t1 is equal to t2 // From ddbe2ef9a19b374c9350ea0476fe86c535f90f1a Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 2 Apr 2017 14:48:17 +0200 Subject: [PATCH 05/94] created .cc files for serialization --- libretroshare/src/libretroshare.pro | 7 + libretroshare/src/serialiser/rsserial.h | 5 +- .../src/serialization/rsserializable.h | 35 ---- .../src/serialization/rsserializer.cc | 67 +++++++ .../src/serialization/rsserializer.h | 63 +------ .../src/serialization/rstypeserializer.h | 164 +----------------- 6 files changed, 82 insertions(+), 259 deletions(-) delete mode 100644 libretroshare/src/serialization/rsserializable.h create mode 100644 libretroshare/src/serialization/rsserializer.cc diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 551fbf335..1b437282c 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -771,6 +771,13 @@ HEADERS += gxstunnel/p3gxstunnel.h \ SOURCES += gxstunnel/p3gxstunnel.cc \ gxstunnel/rsgxstunnelitems.cc +# new serialization code +HEADERS += serialization/rsserializer.h \ + serialization/rstypeserializer.h + +SOURCES += serialization/rsserializer.cc \ + serialization/rstypeserializer.cc + # Identity Service HEADERS += retroshare/rsidentity.h \ gxs/rsgixs.h \ diff --git a/libretroshare/src/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index ad735abe5..2b4aa304d 100644 --- a/libretroshare/src/serialiser/rsserial.h +++ b/libretroshare/src/serialiser/rsserial.h @@ -122,7 +122,10 @@ class RsItem: public RsMemoryManagement::SmallObject */ typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03} SerializeJob ; - virtual void serial_process(SerializeJob j,SerializeContext& ctx) = 0; + virtual void serial_process(SerializeJob j,SerializeContext& ctx) + { + std::cerr << "(EE) RsItem::serial_process() called by an item using new serialization classes, but not derived! " << std::endl; + } private: uint32_t type; diff --git a/libretroshare/src/serialization/rsserializable.h b/libretroshare/src/serialization/rsserializable.h deleted file mode 100644 index 3351e0147..000000000 --- a/libretroshare/src/serialization/rsserializable.h +++ /dev/null @@ -1,35 +0,0 @@ -#pragma once - -#include "serialiser/rsserial.h" - -class RsItem ; -class SerializeContext; - -#define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " - -class RsSerializable: public RsItem -{ -public: - typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03} SerializeJob ; - - RsSerializable(uint8_t version,uint16_t service,uint8_t id) - : RsItem(version,service,id) - { - } - - /** - * @brief serialize this object to the given buffer - * @param Job to do: serialise or deserialize. - * @param data Chunk of memory were to dump the serialized data - * @param size Size of memory chunk - * @param offset Readed to determine at witch offset start writing data, - * written to inform caller were written data ends, the updated value - * is usually passed by the caller to serialize of another - * RsSerializable so it can write on the same chunk of memory just - * after where this RsSerializable has been serialized. - * @return true if serialization successed, false otherwise - */ - - virtual void serial_process(SerializeJob j,SerializeContext& ctx) = 0; -}; - diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc new file mode 100644 index 000000000..cf8976fc1 --- /dev/null +++ b/libretroshare/src/serialization/rsserializer.cc @@ -0,0 +1,67 @@ +#pragma once + +#include "serialization/rsserializer.h" + +RsItem *RsSerializer::deserialise(const uint8_t *data,uint32_t size) +{ + uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; + + RsItem *item = create_item(getRsItemService(rstype),getRsItemSubType(rstype)) ; + + if(!item) + { + std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; + return NULL ; + } + + SerializeContext ctx(const_cast(data),size); + ctx.mOffset = 8 ; + + item->serial_process(RsItem::DESERIALIZE, ctx) ; + + if(ctx.mOk) + return item ; + + delete item ; + return NULL ; +} + +bool RsSerializer::serialise(RsItem *item,uint8_t *const data,uint32_t size) +{ + SerializeContext ctx(data,0); + + uint32_t tlvsize = this->size(item) ; + + if(tlvsize > size) + throw std::runtime_error("Cannot serialise: not enough room.") ; + + if(!setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize)) + { + std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; + return false ; + } + ctx.mOffset = 8; + ctx.mSize = tlvsize; + + item->serial_process(RsItem::SERIALIZE,ctx) ; + + if(ctx.mSize != ctx.mOffset) + { + std::cerr << "RsSerializer::serialise_item(): ERROR. offset does not match expected size!" << std::endl; + return false ; + } + return true ; +} + +uint32_t RsSerializer::size(RsItem *item) +{ + SerializeContext ctx(NULL,0); + + ctx.mSize = 8 ; // header size + item->serial_process(RsItem::SIZE_ESTIMATE, ctx) ; + + return ctx.mSize ; +} + + + diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index e7725b955..102bc4dce 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -35,66 +35,9 @@ class RsSerializer: public RsSerialType return NULL ; } - RsItem *deserialise(const uint8_t *data,uint32_t size) - { - uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; - - RsItem *item = create_item(getRsItemService(rstype),getRsItemSubType(rstype)) ; - - if(!item) - { - std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; - return NULL ; - } - - SerializeContext ctx(const_cast(data),size); - ctx.mOffset = 8 ; - - item->serial_process(RsItem::DESERIALIZE, ctx) ; - - if(ctx.mOk) - return item ; - - delete item ; - return NULL ; - } - - bool serialise(RsItem *item,uint8_t *const data,uint32_t size) - { - SerializeContext ctx(data,0); - - uint32_t tlvsize = this->size(item) ; - - if(tlvsize > size) - throw std::runtime_error("Cannot serialise: not enough room.") ; - - if(!setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize)) - { - std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; - return false ; - } - ctx.mOffset = 8; - ctx.mSize = tlvsize; - - item->serial_process(RsItem::SERIALIZE,ctx) ; - - if(ctx.mSize != ctx.mOffset) - { - std::cerr << "RsSerializer::serialise_item(): ERROR. offset does not match expected size!" << std::endl; - return false ; - } - return true ; - } - - uint32_t size(RsItem *item) - { - SerializeContext ctx(NULL,0); - - ctx.mSize = 8 ; // header size - item->serial_process(RsItem::SIZE_ESTIMATE, ctx) ; - - return ctx.mSize ; - } + RsItem *deserialise(const uint8_t *data,uint32_t size) ; + bool serialise(RsItem *item,uint8_t *const data,uint32_t size) ; + uint32_t size(RsItem *item) ; }; diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 4661ecc61..5c49d928c 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -1,24 +1,6 @@ +#include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" -template T ntoh(T t) -{ - if(sizeof(T) == 8) return t; - if(sizeof(T) == 4) return ntohl(t) ; - if(sizeof(T) == 2) return ntohs(t) ; - - std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in ntoh<>" << std::endl; - return t; -} -template T hton(T t) -{ - if(sizeof(T) == 8) return t; - if(sizeof(T) == 4) return htonl(t) ; - if(sizeof(T) == 2) return htons(t) ; - - std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in hton<>" << std::endl; - return t; -} - class RsTypeSerializer { public: @@ -48,148 +30,4 @@ class RsTypeSerializer template static uint32_t serial_size(const T& /* member */); }; -/// Templates to generate RsSerializer for standard integral types -// -template class t_SerializerNType -{ -public: - static bool serialize(uint8_t data[], uint32_t size, uint32_t &offset, const N& member) - { - if (size <= offset || size < SIZE + offset) - { - SERIALIZE_ERROR() << ": not enough room. SIZE+offset=" << SIZE+offset << " and size is only " << size << std::endl; - return false; - } - - N tmp = hton(member); - memcpy(data+offset, &tmp, SIZE); - offset += SIZE; - return true; - } - static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, N& member) - { - if (size <= offset || size < offset + SIZE) - { - SERIALIZE_ERROR() << ": not enough room. SIZE+offset=" << SIZE+offset << " and size is only " << size << std::endl; - return false; - } - - N tmp ; - memcpy(&tmp, data+offset, SIZE); - member = ntoh(tmp); - offset += SIZE; - return true; - } - - static uint32_t serial_size(const N& /* member */) - { - return SIZE; - } -}; - -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint8_t& member) -{ - return t_SerializerNType::serialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint32_t& member) -{ - return t_SerializerNType::serialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint64_t& member) -{ - return t_SerializerNType::serialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint8_t& member) -{ - return t_SerializerNType::deserialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint32_t& member) -{ - return t_SerializerNType::deserialize(data,size,offset,member); -} -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint64_t& member) -{ - return t_SerializerNType::deserialize(data,size,offset,member); -} -template<> uint32_t RsTypeSerializer::serial_size(const uint8_t& member) -{ - return t_SerializerNType::serial_size(member); -} -template<> uint32_t RsTypeSerializer::serial_size(const uint32_t& member) -{ - return t_SerializerNType::serial_size(member); -} -template<> uint32_t RsTypeSerializer::serial_size(const uint64_t& member) -{ - return t_SerializerNType::serial_size(member); -} -//// Float -// -template<> uint32_t RsTypeSerializer::serial_size(const float&){ return 4; } - -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t& offset, const float& f) -{ - uint32_t sz = serial_size(f); - - if ( !data || size <= offset || size < sz + offset ) - { - SERIALIZE_ERROR() << ": not enough room. SIZE+offset=" << sz+offset << " and size is only " << size << std::endl; - return false; - } - - const float tmp = f; - if(tmp < 0.0f) - { - SERIALIZE_ERROR() << "Cannot serialise invalid negative float value " << tmp << std::endl; - return false; - } - - /* This serialisation is quite accurate. The max relative error is approx. - * 0.01% and most of the time less than 1e-05% The error is well distributed - * over numbers also. */ - - uint32_t n; - if(tmp < 1e-7) n = (~(uint32_t)0); - else n = ((uint32_t)( (1.0f/(1.0f+tmp) * (~(uint32_t)0)))); - n = hton(n); - memcpy(data+offset, &n, sz); - offset += sz; - return true; -} - - -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, float& f) -{ - uint32_t sz = serial_size(f); - - if ( !data || size <= offset || size < offset + sz ) - { - SERIALIZE_ERROR() << "Cannot deserialise float value. Not enough room. size=" << size << ", offset=" << offset << std::endl; - return false; - } - - uint32_t n; - memcpy(&n, data+offset, sz); - n = ntoh(n); - f = 1.0f/ ( n/(float)(~(uint32_t)0)) - 1.0f; - return true; -} - -typedef std::pair TlvString; - -/// Serializer for std::string -template<> uint32_t RsTypeSerializer::serial_size(const TlvString& s) -{ - return GetTlvStringSize(s.first) ; -} - -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const TlvString& s) -{ - return SetTlvString(data,size,&offset,s.second,s.first) ; -} - -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,TlvString& s) -{ - return GetTlvString((void*)data,size,&offset,s.second,s.first) ; -} From 75a3cf0f3b9e0cdd746311d30b6d0cdb2c6a7312 Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 2 Apr 2017 15:04:03 +0200 Subject: [PATCH 06/94] fixed compilation in new serialization test code --- libretroshare/src/serialization/rsserializer.cc | 2 ++ libretroshare/src/serialization/rstypeserializer.h | 8 ++++++-- libretroshare/src/serialization/serial_test.cc | 7 +++++-- 3 files changed, 13 insertions(+), 4 deletions(-) diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index cf8976fc1..e12878b1d 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -1,5 +1,6 @@ #pragma once +#include "util/rsprint.h" #include "serialization/rsserializer.h" RsItem *RsSerializer::deserialise(const uint8_t *data,uint32_t size) @@ -11,6 +12,7 @@ RsItem *RsSerializer::deserialise(const uint8_t *data,uint32_t size) if(!item) { std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; + std::cerr << "(EE) Data is: " << RsUtil::BinToHex(data,std::min(50u,size)) << ((size>50)?"...":"") << std::endl; return NULL ; } diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 5c49d928c..25c4d45b2 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -4,8 +4,12 @@ class RsTypeSerializer { public: - template - static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member) + // This type should be used to pass a parameter to drive the serialisation if needed. + + typedef std::pair TlvString; + + template + static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member) { switch(j) { diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc index f1698ad0c..24822284e 100644 --- a/libretroshare/src/serialization/serial_test.cc +++ b/libretroshare/src/serialization/serial_test.cc @@ -92,7 +92,7 @@ class RsTestItem: public RsItem // virtual void serial_process(RsItem::SerializeJob j, SerializeContext& ctx) { - TlvString tt(str,TLV_TYPE_STR_DESCR) ; + RsTypeSerializer::TlvString tt(str,TLV_TYPE_STR_DESCR) ; RsTypeSerializer::serial_process(j,ctx,ts ) ; RsTypeSerializer::serial_process(j,ctx,tt ) ; @@ -121,8 +121,11 @@ class RsTestSerializer: public RsSerializer public: RsTestSerializer() : RsSerializer(RS_SERVICE_TYPE_TEST) {} - virtual RsItem *create_item(uint8_t subtype) + virtual RsItem *create_item(uint16_t service_id,uint8_t subtype) { + if(service_id != RS_SERVICE_TYPE_TEST) + return NULL ; + switch(subtype) { case RS_ITEM_SUBTYPE_TEST1: return new RsTestItem(); From 059dfcff47956dd9182f378a377414fec05bb640 Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 4 Apr 2017 14:00:17 +0200 Subject: [PATCH 07/94] added hability to print in the serialization process --- libretroshare/src/serialiser/rsserial.h | 2 +- .../src/serialization/rsserializer.cc | 8 ++++++++ .../src/serialization/rstypeserializer.h | 6 +++++- .../src/serialization/serial_test.cc | 20 ++++++++++++++----- 4 files changed, 29 insertions(+), 7 deletions(-) diff --git a/libretroshare/src/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index 2b4aa304d..0abc63af6 100644 --- a/libretroshare/src/serialiser/rsserial.h +++ b/libretroshare/src/serialiser/rsserial.h @@ -120,7 +120,7 @@ class RsItem: public RsMemoryManagement::SmallObject * after where this RsSerializable has been serialized. * @return true if serialization successed, false otherwise */ - typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03} SerializeJob ; + typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03, PRINT=0x04 } SerializeJob ; virtual void serial_process(SerializeJob j,SerializeContext& ctx) { diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index e12878b1d..f7926f8e2 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -65,5 +65,13 @@ uint32_t RsSerializer::size(RsItem *item) return ctx.mSize ; } +void RsSerializer::print(RsItem *item) +{ + SerializeContext ctx(NULL,0); + + std::cerr << "***** RsItem class: \"" << typeid(*item).name() << "\" *****" << std::endl; + item->serial_process(RsItem::PRINT, ctx) ; + std::cerr << "******************************" << std::endl; +} diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 25c4d45b2..37c1f9dc7 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -9,7 +9,7 @@ class RsTypeSerializer typedef std::pair TlvString; template - static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member) + static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member,const std::string& member_name) { switch(j) { @@ -22,6 +22,9 @@ class RsTypeSerializer case RsItem::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; break ; + case RsItem::PRINT: + print_data(member_name,member); + break; default: ctx.mOk = false ; throw std::runtime_error("Unknown serial job") ; @@ -32,6 +35,7 @@ class RsTypeSerializer template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member); template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); template static uint32_t serial_size(const T& /* member */); + template static void print_data(const std::string& name,const T& /* member */); }; diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc index 24822284e..786fd1d88 100644 --- a/libretroshare/src/serialization/serial_test.cc +++ b/libretroshare/src/serialization/serial_test.cc @@ -11,6 +11,8 @@ #include "rsserializer.h" #include "rstypeserializer.h" +#define GET_VARIABLE_NAME(str) #str + static const uint16_t RS_SERVICE_TYPE_TEST = 0xffff; static const uint8_t RS_ITEM_SUBTYPE_TEST1 = 0x01 ; @@ -71,6 +73,11 @@ template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t siz return ok; } +template<> void RsTypeSerializer::print_data(const std::string& s,const std::set& set) +{ + std::cerr << " [set] " << s << " : set of size " << set.size() << std::endl; +} + // New item class. This class needs to define: // - a serial_process method that tells which members to serialize // - overload the clear() and print() methods of RsItem @@ -94,15 +101,15 @@ class RsTestItem: public RsItem { RsTypeSerializer::TlvString tt(str,TLV_TYPE_STR_DESCR) ; - RsTypeSerializer::serial_process(j,ctx,ts ) ; - RsTypeSerializer::serial_process(j,ctx,tt ) ; - RsTypeSerializer::serial_process(j,ctx,int_set ) ; + RsTypeSerializer::serial_process(j,ctx,ts ,GET_VARIABLE_NAME(ts) ) ; + RsTypeSerializer::serial_process(j,ctx,tt ,GET_VARIABLE_NAME(str) ) ; + RsTypeSerializer::serial_process(j,ctx,int_set,GET_VARIABLE_NAME(int_set) ) ; } - // Derived from RsItem + // Derived from RsItem, because they are pure virtuals. Normally print() should disappear soon. // virtual void clear() {} - virtual std::ostream& print(std::ostream&,uint16_t indent) {} + virtual std::ostream& print(std::ostream&,uint16_t) {} private: std::string str ; @@ -156,6 +163,9 @@ int main(int argc,char *argv[]) // RsTemporaryMemory mem1(size); + std::cerr << "Item to be serialized:" << std::endl; + + RsTestSerializer().print(&t1) ; RsTestSerializer().serialise(&t1,mem1,mem1.size()) ; std::cerr << "Serialized t1: " << RsUtil::BinToHex(mem1,mem1.size()) << std::endl; From f7e396856e0e044bc1e35bced8f0e9de6f6c48e3 Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 4 Apr 2017 14:01:33 +0200 Subject: [PATCH 08/94] added hability to print in the serialization process --- libretroshare/src/serialization/rsserializer.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 102bc4dce..ea20845b7 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -35,9 +35,13 @@ class RsSerializer: public RsSerialType return NULL ; } + // The following functions *should not* be overloaded. + // They are kept public in order to allow them to be called if needed. + RsItem *deserialise(const uint8_t *data,uint32_t size) ; bool serialise(RsItem *item,uint8_t *const data,uint32_t size) ; uint32_t size(RsItem *item) ; + void print(RsItem *item) ; }; From 32ce9aea3a2990425c62305731480998d793b50b Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 4 Apr 2017 15:33:59 +0200 Subject: [PATCH 09/94] started converting rschatitems to new serialization --- libretroshare/src/chat/distantchat.cc | 2 +- libretroshare/src/chat/rschatitems.cc | 139 ++++++++++++------ libretroshare/src/chat/rschatitems.h | 33 ++--- .../src/serialization/rsserializer.cc | 4 +- .../src/serialization/rstypeserializer.h | 2 +- 5 files changed, 106 insertions(+), 74 deletions(-) diff --git a/libretroshare/src/chat/distantchat.cc b/libretroshare/src/chat/distantchat.cc index 70fb88d8c..3f0e26b83 100644 --- a/libretroshare/src/chat/distantchat.cc +++ b/libretroshare/src/chat/distantchat.cc @@ -218,7 +218,7 @@ void DistantChatService::receiveData(const RsGxsTunnelService::RsGxsTunnelId &tu contact.from_id = tinfo.source_gxs_id ; } - RsItem *item = RsChatSerialiser().deserialise(data,&data_size) ; + RsItem *item = RsChatSerialiser().deserialise(data,data_size) ; if(item != NULL) { diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 90cf78fa6..3e2bd7d5a 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -29,10 +29,13 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" +#include "serialization/rstypeserializer.h" + #include "chat/rschatitems.h" //#define CHAT_DEBUG 1 +#ifdef TO_BE_REMOVED std::ostream& RsChatMsgItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsChatMsgItem", indent); @@ -220,57 +223,44 @@ std::ostream& RsChatAvatarItem::print(std::ostream &out, uint16_t indent) return out; } -RsItem *RsChatSerialiser::deserialise(void *data, uint32_t *pktsize) +#endif + +RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) { - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); + if(service_id != RS_SERVICE_TYPE_CHAT) + return NULL ; -#ifdef CHAT_DEBUG - std::cerr << "deserializing packet..."<< std::endl ; -#endif - // look what we have... - if (*pktsize < rssize) /* check size */ + switch(item_sub_id) { -#ifdef CHAT_DEBUG - std::cerr << "chat deserialisation: not enough size: pktsize=" << *pktsize << ", rssize=" << rssize << std::endl ; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *pktsize = rssize; - - /* ready to load */ - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_CHAT != getRsItemService(rstype))) - { -#ifdef CHAT_DEBUG - std::cerr << "chat deserialisation: wrong type !" << std::endl ; -#endif - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_DEFAULT: return new RsChatMsgItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG: return new RsPrivateChatMsgConfigItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_DISTANT_INVITE_CONFIG: return new RsPrivateChatDistantInviteConfigItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_CHAT_STATUS: return new RsChatStatusItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_CHAT_AVATAR: return new RsChatAvatarItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_MSG: return new RsChatLobbyMsgItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE: return new RsChatLobbyInviteItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_CHAT_LOBBY_CHALLENGE: return new RsChatLobbyConnectChallengeItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_CHAT_LOBBY_UNSUBSCRIBE: return new RsChatLobbyUnsubscribeItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_EVENT: return new RsChatLobbyEventItem(data,*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_DEFAULT: return new RsChatMsgItem() ; + case RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG: return new RsPrivateChatMsgConfigItem() ; + case RS_PKT_SUBTYPE_DISTANT_INVITE_CONFIG: return new RsPrivateChatDistantInviteConfigItem() ; + case RS_PKT_SUBTYPE_CHAT_STATUS: return new RsChatStatusItem() ; + case RS_PKT_SUBTYPE_CHAT_AVATAR: return new RsChatAvatarItem() ; + case RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_MSG: return new RsChatLobbyMsgItem() ; + case RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE: return new RsChatLobbyInviteItem() ; + case RS_PKT_SUBTYPE_CHAT_LOBBY_CHALLENGE: return new RsChatLobbyConnectChallengeItem() ; + case RS_PKT_SUBTYPE_CHAT_LOBBY_UNSUBSCRIBE: return new RsChatLobbyUnsubscribeItem() ; + case RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_EVENT:return new RsChatLobbyEventItem() ; + case RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_REQUEST:return new RsChatLobbyListRequestItem() ; + case RS_PKT_SUBTYPE_CHAT_LOBBY_LIST: return new RsChatLobbyListItem() ; + case RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG: return new RsChatLobbyConfigItem() ; default: std::cerr << "Unknown packet type in chat!" << std::endl ; return NULL ; } } +void RsChatMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::TlvString tt(str,TLV_TYPE_STR_MSG) ; + + RsTypeSerializer::serial_process(j,ctx,chatFlags,"chatflags") ; + RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; + RsTypeSerializer::serial_process(j,ctx,tt,"message") ; +} + +#ifdef TO_BE_REMOVED uint32_t RsChatMsgItem::serial_size() { uint32_t s = 8; /* header */ @@ -423,6 +413,7 @@ uint32_t RsChatLobbyConfigItem::serial_size() return s; } +#endif /*************************************************************************/ @@ -435,6 +426,7 @@ RsChatAvatarItem::~RsChatAvatarItem() } } +#ifdef TO_BE_REMOVED /* serialise the data to the buffer */ bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize) { @@ -481,21 +473,40 @@ bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize) #endif return ok ; } +#endif -bool RsChatLobbyBouncingObject::serialise_to_memory(void *data,uint32_t tlvsize,uint32_t& offset,bool include_signature) +bool RsChatLobbyBouncingObject::serialise_to_memory(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature) { - bool ok = true ; + TlvString tt(nick,TLV_TYPE_STR_NAME) ; - ok &= setRawUInt64(data, tlvsize, &offset, lobby_id); - ok &= setRawUInt64(data, tlvsize, &offset, msg_id); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, nick); + RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; + RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; + RsTypeSerializer::serial_process(j,ctx,tt ,"nick") ; if(include_signature) - ok &= signature.SetTlv(data, tlvsize, &offset); + RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; - return ok ; + return true ; } +void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsChatMsgItem::serial_process(j,ctx) ; + + if(j == RsItem::SERIALIZE) + { + SerializeContext ctx2 ; + serial_process(RsItem::SIZE_ESTIMATE,ctx2); + + setRsItemHeader(ctx.mData, ctx.mSize, PacketId(), ctx2.mOffset); // correct header! + } + + RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; + + ctx.mOk &= RsChatLobbyBouncingObject::serialise_to_memory(j,ctx,true) ; +} + +#ifdef TO_BE_REMOVED /* serialise the data to the buffer */ bool RsChatLobbyMsgItem::serialise(void *data, uint32_t& pktsize) { @@ -528,6 +539,8 @@ bool RsChatLobbyMsgItem::serialise(void *data, uint32_t& pktsize) #endif return ok ; } +#endif + /* serialise the data to the buffer */ bool RsChatLobbyMsgItem::serialise_signed_part(void *data, uint32_t& pktsize) { @@ -562,7 +575,12 @@ bool RsChatLobbyMsgItem::serialise_signed_part(void *data, uint32_t& pktsize) return ok ; } +void RsChatLobbyListRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + // nothing to do. This is an empty item. +} +#ifdef TO_BE_REMOVED bool RsChatLobbyListRequestItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -575,6 +593,27 @@ bool RsChatLobbyListRequestItem::serialise(void *data, uint32_t& pktsize) pktsize = tlvsize ; return ok ; } +#endif + +template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,VisibleChatLobbyInfo& info) +{ + RsTypeSerializer::serial_process(info.id) ; + + TlvString tt1(info.name ,TLV_TYPE_STR_NAME) ; + TlvString tt2(info.topic,TLV_TYPE_STR_NAME) ; + + RsTypeSerializer::serial_process(info.name) ; + RsTypeSerializer::serial_process(info.topic) ; + RsTypeSerializer::serial_process(info.count) ; + RsTypeSerializer::serial_process(info.flags.toUInt32()) ; +} + +void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,lobbies,"lobbies") ; +} + +#ifdef TO_BE_REMOVED bool RsChatLobbyListItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -604,6 +643,8 @@ bool RsChatLobbyListItem::serialise(void *data, uint32_t& pktsize) } return ok ; } +#endif + bool RsChatLobbyEventItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 13b42c18f..2ce127196 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -27,6 +27,7 @@ #include "openssl/bn.h" #include "retroshare/rstypes.h" +#include "serialization/rsserializer.h" #include "serialiser/rstlvkeys.h" #include "serialiser/rsserviceids.h" #include "serialiser/rsserial.h" @@ -90,11 +91,9 @@ class RsChatItem: public RsItem } virtual ~RsChatItem() {} - virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0 ; + virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) {} // derived from RsItem, but should be removed - virtual bool serialise(void *data,uint32_t& size) = 0 ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() = 0 ; // deserialise is handled using a constructor + virtual void clear() {} }; /*! @@ -107,14 +106,14 @@ public: RsChatMsgItem() :RsChatItem(RS_PKT_SUBTYPE_DEFAULT) {} RsChatMsgItem(uint8_t subtype) :RsChatItem(subtype) {} - RsChatMsgItem(void *data,uint32_t size,uint8_t subtype = RS_PKT_SUBTYPE_DEFAULT) ; // deserialization + //RsChatMsgItem() {} virtual ~RsChatMsgItem() {} - virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + // derived from RsItem + + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + virtual void clear() {} uint32_t chatFlags; uint32_t sendTime; @@ -150,7 +149,7 @@ protected: // serialise() methods, otherwise the wrong method will be called when serialising from this top level class. uint32_t serialized_size(bool include_signature) ; - bool serialise_to_memory(void *data,uint32_t tlvsize,uint32_t& offset,bool include_signature) ; + bool serialise_to_memory(RsItem::SerializeJob j, SerializeContext &ctx, bool include_signature) ; bool deserialise_from_memory(void *data,uint32_t rssize,uint32_t& offset) ; }; @@ -413,19 +412,11 @@ class RsChatDHPublicKeyItem: public RsChatItem const RsChatDHPublicKeyItem& operator=(const RsChatDHPublicKeyItem&) { return *this ;} }; -class RsChatSerialiser: public RsSerialType +class RsChatSerialiser: public RsSerializer { public: - RsChatSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_CHAT) {} + RsChatSerialiser() :RsSerializer(RS_SERVICE_TYPE_CHAT) {} - virtual uint32_t size (RsItem *item) - { - return static_cast(item)->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - return static_cast(item)->serialise(data,*size) ; - } - virtual RsItem *deserialise (void *data, uint32_t *size) ; + virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) ; }; diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index f7926f8e2..b17785038 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -59,10 +59,10 @@ uint32_t RsSerializer::size(RsItem *item) { SerializeContext ctx(NULL,0); - ctx.mSize = 8 ; // header size + ctx.mOffset = 8 ; // header size item->serial_process(RsItem::SIZE_ESTIMATE, ctx) ; - return ctx.mSize ; + return ctx.mOffset ; } void RsSerializer::print(RsItem *item) diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 37c1f9dc7..1e4d5b20b 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -13,7 +13,7 @@ class RsTypeSerializer { switch(j) { - case RsItem::SIZE_ESTIMATE: ctx.mSize += serial_size(member) ; + case RsItem::SIZE_ESTIMATE: ctx.mOffset += serial_size(member) ; break ; case RsItem::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; From f2fa70e39562a0d80d85df0abf7ab52ad7f4472a Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 4 Apr 2017 16:37:57 +0200 Subject: [PATCH 10/94] progress in converting Chat items to new serialization model --- libretroshare/src/chat/distantchat.cc | 8 +- libretroshare/src/chat/distributedchat.cc | 2 +- libretroshare/src/chat/rschatitems.cc | 91 ++++++++++++-- libretroshare/src/chat/rschatitems.h | 113 ++++-------------- .../src/serialization/rsserializer.h | 13 -- .../src/serialization/rstypeserializer.h | 25 ++++ 6 files changed, 136 insertions(+), 116 deletions(-) diff --git a/libretroshare/src/chat/distantchat.cc b/libretroshare/src/chat/distantchat.cc index 3f0e26b83..576e97efe 100644 --- a/libretroshare/src/chat/distantchat.cc +++ b/libretroshare/src/chat/distantchat.cc @@ -89,10 +89,10 @@ bool DistantChatService::handleOutgoingItem(RsChatItem *item) std::cerr << "p3ChatService::handleOutgoingItem(): sending to " << item->PeerId() << ": interpreted as a distant chat virtual peer id." << std::endl; #endif - uint32_t size = item->serial_size() ; + uint32_t size = RsChatSerialiser().size(item) ; RsTemporaryMemory mem(size) ; - if(!item->serialise(mem,size)) + if(!RsChatSerialiser().serialise(item,mem,size)) { std::cerr << "(EE) serialisation error. Something's really wrong!" << std::endl; return false; @@ -149,10 +149,10 @@ bool DistantChatService::acceptDataFromPeer(const RsGxsId& gxs_id,const RsGxsTun // we do not use handleOutGoingItem() because there's no distant chat contact, as the chat is refused. - uint32_t size = item->serial_size() ; + uint32_t size = RsChatSerialiser().size(item) ; RsTemporaryMemory mem(size) ; - if(!item->serialise(mem,size)) + if(!RsChatSerialiser().serialise(item,mem,size)) { std::cerr << "(EE) serialisation error. Something's really wrong!" << std::endl; return false; diff --git a/libretroshare/src/chat/distributedchat.cc b/libretroshare/src/chat/distributedchat.cc index 05312e1a9..52c9e6ffb 100644 --- a/libretroshare/src/chat/distributedchat.cc +++ b/libretroshare/src/chat/distributedchat.cc @@ -415,7 +415,7 @@ void DistributedChatService::checkSizeAndSendLobbyMessage(RsChatItem *msg) // static const uint32_t MAX_ITEM_SIZE = 32000 ; - if(msg->serial_size() > MAX_ITEM_SIZE) + if(RsChatSerialiser().size(msg) > MAX_ITEM_SIZE) { std::cerr << "(EE) Chat item exceeds maximum serial size. It will be dropped." << std::endl; delete msg ; diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 3e2bd7d5a..aa0a19cda 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -234,7 +234,6 @@ RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) { case RS_PKT_SUBTYPE_DEFAULT: return new RsChatMsgItem() ; case RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG: return new RsPrivateChatMsgConfigItem() ; - case RS_PKT_SUBTYPE_DISTANT_INVITE_CONFIG: return new RsPrivateChatDistantInviteConfigItem() ; case RS_PKT_SUBTYPE_CHAT_STATUS: return new RsChatStatusItem() ; case RS_PKT_SUBTYPE_CHAT_AVATAR: return new RsChatAvatarItem() ; case RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_MSG: return new RsChatLobbyMsgItem() ; @@ -253,7 +252,7 @@ RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) void RsChatMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::TlvString tt(str,TLV_TYPE_STR_MSG) ; + RsTypeSerializer::TlvString tt(message,TLV_TYPE_STR_MSG) ; RsTypeSerializer::serial_process(j,ctx,chatFlags,"chatflags") ; RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; @@ -475,9 +474,9 @@ bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize) } #endif -bool RsChatLobbyBouncingObject::serialise_to_memory(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature) +void RsChatLobbyBouncingObject::serial_process_special(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature) { - TlvString tt(nick,TLV_TYPE_STR_NAME) ; + RsTypeSerializer::TlvString tt(nick,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; @@ -485,8 +484,6 @@ bool RsChatLobbyBouncingObject::serialise_to_memory(RsItem::SerializeJob j,Seria if(include_signature) RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; - - return true ; } void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) @@ -495,7 +492,7 @@ void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& if(j == RsItem::SERIALIZE) { - SerializeContext ctx2 ; + SerializeContext ctx2(NULL,0) ; serial_process(RsItem::SIZE_ESTIMATE,ctx2); setRsItemHeader(ctx.mData, ctx.mSize, PacketId(), ctx2.mOffset); // correct header! @@ -503,7 +500,7 @@ void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; - ctx.mOk &= RsChatLobbyBouncingObject::serialise_to_memory(j,ctx,true) ; + RsChatLobbyBouncingObject::serial_process_special(j,ctx,true) ; } #ifdef TO_BE_REMOVED @@ -561,7 +558,7 @@ bool RsChatLobbyMsgItem::serialise_signed_part(void *data, uint32_t& pktsize) // The signature is at the end of the serialised data, so that the signed data is *before* the signature. - ok &= RsChatLobbyBouncingObject::serialise_to_memory(data,tlvsize,offset,false) ; + ok &= RsChatLobbyBouncingObject::serial_process_special(data,tlvsize,offset,false) ; /* add mandatory parts first */ if (offset != tlvsize) @@ -706,6 +703,12 @@ bool RsChatLobbyEventItem::serialise_signed_part(void *data, uint32_t& pktsize) return ok ; } +void RsChatLobbyUnsubscribeItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; +} + +#ifdef TO_BE_REMOVED bool RsChatLobbyUnsubscribeItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -730,6 +733,14 @@ bool RsChatLobbyUnsubscribeItem::serialise(void *data, uint32_t& pktsize) pktsize = tlvsize ; return ok ; } +#endif + +void RsChatLobbyConnectChallengeItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,challenge_code,"challenge_code") ; +} + +#ifdef TO_BE_REMOVED bool RsChatLobbyConnectChallengeItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -754,7 +765,19 @@ bool RsChatLobbyConnectChallengeItem::serialise(void *data, uint32_t& pktsize) pktsize = tlvsize ; return ok ; } +#endif +void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; + + TlvString s(message,TLV_TYPE_STR_NAME) ; + + RsTypeSerializer::serial_process(j,ctx,s,"lobby_name") ; + RsTypeSerializer::serial_process(j,ctx,lobby_flags.toUInt32(),"lobby_flags") ; +} + +#ifdef TO_BE_REMOVED bool RsChatLobbyInviteItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -781,7 +804,22 @@ bool RsChatLobbyInviteItem::serialise(void *data, uint32_t& pktsize) pktsize = tlvsize ; return ok ; } +#endif +void RsPrivateChatMsgConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + uint32_t x=0 ; + TlvString s(message,TLV_TYPE_STR_MSG) ; + + RsTypeSerializer::serial_process(j,ctx,x,"place holder value") ; + RsTypeSerializer::serial_process (j,ctx,configPeerId,"configPeerId") ; + RsTypeSerializer::serial_process(j,ctx,chatFlags,"chatFlags") ; + RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; + RsTypeSerializer::serial_process (j,ctx,s,"message") ; + RsTypeSerializer::serial_process(j,ctx,recvTime,"recvTime") ; +} + +#ifdef TO_BE_REMOVED bool RsPrivateChatMsgConfigItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -821,6 +859,7 @@ bool RsPrivateChatMsgConfigItem::serialise(void *data, uint32_t& pktsize) return ok; } + bool RsPrivateChatDistantInviteConfigItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -863,6 +902,18 @@ bool RsPrivateChatDistantInviteConfigItem::serialise(void *data, uint32_t& pktsi return ok; } +#endif + +void RsChatStatusItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; + + RsTypeSerializer::TlvString tt(status_string,TLV_TYPE_STR_MSG) ; + + RsTypeSerializer::serial_process(j,ctx,tt,"status_string") ; +} + +#ifdef TO_BE_REMOVED bool RsChatStatusItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -901,7 +952,14 @@ bool RsChatStatusItem::serialise(void *data, uint32_t& pktsize) return ok; } +#endif +void RsChatAvatarItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,RsTypeSerializer::BinaryDataBlock(data,image_size)) ; +} + +#ifdef TO_BE_REMOVED bool RsChatAvatarItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -942,6 +1000,15 @@ bool RsChatAvatarItem::serialise(void *data, uint32_t& pktsize) return ok; } +#endif + +void RsChatLobbyConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,lobby_Id,"lobby_Id") ; + RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; +} + +#ifdef TO_BE_REMOVED bool RsChatLobbyConfigItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -1067,6 +1134,7 @@ RsChatLobbyListItem::RsChatLobbyListItem(void *data,uint32_t) if (!ok) std::cerr << "Unknown error while deserializing." << std::endl ; } +#endif bool RsChatLobbyBouncingObject::deserialise_from_memory(void *data,uint32_t rssize,uint32_t& offset) { @@ -1103,6 +1171,8 @@ RsChatLobbyEventItem::RsChatLobbyEventItem(void *data,uint32_t /*size*/) if (!ok) std::cerr << "Unknown error while deserializing." << std::endl ; } + +#ifdef TO_BE_REMOVED RsChatLobbyUnsubscribeItem::RsChatLobbyUnsubscribeItem(void *data,uint32_t /*size*/) : RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_UNSUBSCRIBE) { @@ -1246,6 +1316,7 @@ RsChatLobbyConfigItem::RsChatLobbyConfigItem(void *data,uint32_t /*size*/) if (!ok) std::cerr << "Unknown error while deserializing." << std::endl ; } +#endif /* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */ void RsPrivateChatMsgConfigItem::set(RsChatMsgItem *ci, const RsPeerId& /*peerId*/, uint32_t confFlags) @@ -1270,6 +1341,7 @@ void RsPrivateChatMsgConfigItem::get(RsChatMsgItem *ci) ci->recvTime = recvTime; } +#ifdef TO_BE_REMOVED RsChatStatusItem::RsChatStatusItem(void *data,uint32_t /*size*/) : RsChatItem(RS_PKT_SUBTYPE_CHAT_STATUS) { @@ -1319,4 +1391,5 @@ RsChatAvatarItem::RsChatAvatarItem(void *data,uint32_t /*size*/) std::cerr << "Unknown error while deserializing." << std::endl ; } +#endif diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 2ce127196..3b04b995c 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -79,7 +79,7 @@ const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE = 0x1A ; typedef uint64_t ChatLobbyId ; typedef uint64_t ChatLobbyMsgId ; -typedef std::string ChatLobbyNickName ; +typedef std::string ChatLobbyNickName ; typedef uint64_t DistantChatDHSessionId ; class RsChatItem: public RsItem @@ -91,7 +91,7 @@ class RsChatItem: public RsItem } virtual ~RsChatItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) {} // derived from RsItem, but should be removed + virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) { return out; } // derived from RsItem, but should be removed virtual void clear() {} }; @@ -136,7 +136,6 @@ public: RsTlvKeySignature signature ; virtual RsChatLobbyBouncingObject *duplicate() const = 0 ; - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); // returns the size in bytes of the data chunk to sign. @@ -148,9 +147,7 @@ protected: // They are called by serial_size() and serialise() from children, but should not overload the serial_size() and // serialise() methods, otherwise the wrong method will be called when serialising from this top level class. - uint32_t serialized_size(bool include_signature) ; - bool serialise_to_memory(RsItem::SerializeJob j, SerializeContext &ctx, bool include_signature) ; - bool deserialise_from_memory(void *data,uint32_t rssize,uint32_t& offset) ; + void serial_process_special(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature); }; class RsChatLobbyMsgItem: public RsChatMsgItem, public RsChatLobbyBouncingObject @@ -158,14 +155,10 @@ class RsChatLobbyMsgItem: public RsChatMsgItem, public RsChatLobbyBouncingObject public: RsChatLobbyMsgItem() :RsChatMsgItem(RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_MSG) {} - RsChatLobbyMsgItem(void *data,uint32_t size) ; // deserialization /// TODO!!! - virtual ~RsChatLobbyMsgItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyMsgItem(*this) ; } - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx) ; virtual uint32_t signed_serial_size() ; virtual bool serialise_signed_part(void *data,uint32_t& size) ;// Isn't it better that items can serialize themselves ? @@ -177,17 +170,14 @@ class RsChatLobbyEventItem: public RsChatItem, public RsChatLobbyBouncingObject { public: RsChatLobbyEventItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_EVENT) {} - RsChatLobbyEventItem(void *data,uint32_t size) ; // deserialization /// TODO!!! virtual ~RsChatLobbyEventItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyEventItem(*this) ; } // - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); virtual uint32_t signed_serial_size() ; - virtual bool serialise_signed_part(void *data,uint32_t& size) ; + virtual bool serialise_signed_part(void *data,uint32_t& size) ; // members. // @@ -200,13 +190,9 @@ class RsChatLobbyListRequestItem: public RsChatItem { public: RsChatLobbyListRequestItem() : RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_REQUEST) {} - RsChatLobbyListRequestItem(void *data,uint32_t size) ; virtual ~RsChatLobbyListRequestItem() {} - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; - - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); }; struct VisibleChatLobbyInfo @@ -222,13 +208,9 @@ class RsChatLobbyListItem: public RsChatItem { public: RsChatLobbyListItem() : RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_LIST) {} - RsChatLobbyListItem(void *data,uint32_t size) ; virtual ~RsChatLobbyListItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); std::vector lobbies ; }; @@ -237,48 +219,38 @@ class RsChatLobbyUnsubscribeItem: public RsChatItem { public: RsChatLobbyUnsubscribeItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_UNSUBSCRIBE) {} - RsChatLobbyUnsubscribeItem(void *data,uint32_t size) ; // deserialization virtual ~RsChatLobbyUnsubscribeItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); uint64_t lobby_id ; - - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor }; class RsChatLobbyConnectChallengeItem: public RsChatItem { public: RsChatLobbyConnectChallengeItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_CHALLENGE) {} - RsChatLobbyConnectChallengeItem(void *data,uint32_t size) ; // deserialization virtual ~RsChatLobbyConnectChallengeItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); uint64_t challenge_code ; - - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor }; class RsChatLobbyInviteItem: public RsChatItem { public: RsChatLobbyInviteItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE) {} - RsChatLobbyInviteItem(void *data,uint32_t size) ; // deserialization - virtual ~RsChatLobbyInviteItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); ChatLobbyId lobby_id ; std::string lobby_name ; std::string lobby_topic ; ChatLobbyFlags lobby_flags ; - - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor }; /*! @@ -289,14 +261,11 @@ class RsPrivateChatMsgConfigItem: public RsChatItem { public: RsPrivateChatMsgConfigItem() :RsChatItem(RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG) {} - RsPrivateChatMsgConfigItem(void *data,uint32_t size) ; // deserialization virtual ~RsPrivateChatMsgConfigItem() {} virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); /* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */ void set(RsChatMsgItem *ci, const RsPeerId &peerId, uint32_t confFlags); @@ -310,43 +279,19 @@ class RsPrivateChatMsgConfigItem: public RsChatItem std::string message; uint32_t recvTime; }; -class RsPrivateChatDistantInviteConfigItem: public RsChatItem -{ - public: - RsPrivateChatDistantInviteConfigItem() :RsChatItem(RS_PKT_SUBTYPE_DISTANT_INVITE_CONFIG) {} - RsPrivateChatDistantInviteConfigItem(void *data,uint32_t size) ; // deserialization - - virtual ~RsPrivateChatDistantInviteConfigItem() {} - virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor - - unsigned char aes_key[16] ; - RsFileHash hash ; - std::string encrypted_radix64_string ; - RsPgpId destination_pgp_id ; - uint32_t time_of_validity ; - uint32_t last_hit_time ; - uint32_t flags ; -}; class RsChatLobbyConfigItem: public RsChatItem { public: - RsChatLobbyConfigItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG) { lobby_Id = 0; } - RsChatLobbyConfigItem(void *data,uint32_t size) ; // deserialization + RsChatLobbyConfigItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG) { lobby_Id = 0; } - virtual ~RsChatLobbyConfigItem() {} + virtual ~RsChatLobbyConfigItem() {} - virtual void clear() { lobby_Id = 0; } - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual void clear() { lobby_Id = 0; } - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); - uint64_t lobby_Id; - uint32_t flags ; + uint64_t lobby_Id; + uint32_t flags ; }; // This class contains activity info for the sending peer: active, idle, typing, etc. @@ -355,13 +300,10 @@ class RsChatStatusItem: public RsChatItem { public: RsChatStatusItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_STATUS) {} - RsChatStatusItem(void *data,uint32_t size) ; // deserialization virtual ~RsChatStatusItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); uint32_t flags ; std::string status_string; @@ -373,13 +315,9 @@ class RsChatAvatarItem: public RsChatItem { public: RsChatAvatarItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_AVATAR) {setPriorityLevel(QOS_PRIORITY_RS_CHAT_AVATAR_ITEM) ;} - RsChatAvatarItem(void *data,uint32_t size) ; // deserialization virtual ~RsChatAvatarItem() ; - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); uint32_t image_size ; // size of data in bytes unsigned char *image_data ; // image @@ -392,13 +330,10 @@ class RsChatDHPublicKeyItem: public RsChatItem { public: RsChatDHPublicKeyItem() :RsChatItem(RS_PKT_SUBTYPE_DISTANT_CHAT_DH_PUBLIC_KEY) {setPriorityLevel(QOS_PRIORITY_RS_CHAT_ITEM) ;} - RsChatDHPublicKeyItem(void *data,uint32_t size) ; // deserialization virtual ~RsChatDHPublicKeyItem() { BN_free(public_key) ; } - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); // Private data to DH public key item // diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index ea20845b7..8c5539088 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -9,19 +9,6 @@ #define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " -class SerializeContext -{ - public: - - SerializeContext(uint8_t *data,uint32_t size) - : mData(data),mSize(size),mOffset(0),mOk(true) {} - - unsigned char *mData ; - uint32_t mSize ; - uint32_t mOffset ; - bool mOk ; -}; - class RsSerializer: public RsSerialType { public: diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 1e4d5b20b..49505fc78 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -1,6 +1,22 @@ +#pragma once + #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" +class SerializeContext +{ + public: + + SerializeContext(uint8_t *data,uint32_t size) + : mData(data),mSize(size),mOffset(0),mOk(true) {} + + unsigned char *mData ; + uint32_t mSize ; + uint32_t mOffset ; + bool mOk ; +}; + + class RsTypeSerializer { public: @@ -8,6 +24,15 @@ class RsTypeSerializer typedef std::pair TlvString; + class BinaryDataBlock_ref + { + public: + BinaryDataBlock_ref(unsigned char *& _mem,uint32_t& _size) : mem(&_mem),size(&_size){} + + unsigned char **mem ; + uint32_t *size ; + }; + template static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member,const std::string& member_name) { From 9438d606096063d10650cfedee49a2712f38bc9a Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 4 Apr 2017 22:53:50 +0200 Subject: [PATCH 11/94] progress in converting Chat items to new serialization model --- libretroshare/src/chat/distributedchat.cc | 10 +- libretroshare/src/chat/rschatitems.cc | 91 ++++++++++++++----- libretroshare/src/chat/rschatitems.h | 25 ++--- .../src/serialization/rstypeserializer.h | 11 ++- 4 files changed, 92 insertions(+), 45 deletions(-) diff --git a/libretroshare/src/chat/distributedchat.cc b/libretroshare/src/chat/distributedchat.cc index 52c9e6ffb..4d1207f8f 100644 --- a/libretroshare/src/chat/distributedchat.cc +++ b/libretroshare/src/chat/distributedchat.cc @@ -222,7 +222,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const mGixs->requestKey(obj->signature.keyId,peer_list,RsIdentityUsage(RS_SERVICE_TYPE_CHAT,RsIdentityUsage::CHAT_LOBBY_MSG_VALIDATION,RsGxsGroupId(),RsGxsMessageId(),obj->lobby_id)); - uint32_t size = obj->signed_serial_size() ; + uint32_t size = obj->serial_size_no_signature() ; RsTemporaryMemory memory(size) ; #ifdef DEBUG_CHAT_LOBBIES @@ -230,7 +230,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const std::cerr << " signature id: " << obj->signature.keyId << std::endl; #endif - if(!obj->serialise_signed_part(memory,size)) + if(!obj->serialize_no_signature(memory,size)) { std::cerr << " (EE) Cannot serialise message item. " << std::endl; return false ; @@ -239,7 +239,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const uint32_t error_status ; RsIdentityUsage use_info(RS_SERVICE_TYPE_CHAT,RsIdentityUsage::CHAT_LOBBY_MSG_VALIDATION,RsGxsGroupId(),RsGxsMessageId(),obj->lobby_id) ; - if(!mGixs->validateData(memory,obj->signed_serial_size(),obj->signature,false,use_info,error_status)) + if(!mGixs->validateData(memory,obj->serial_size_no_signature(),obj->signature,false,use_info,error_status)) { bool res = false ; @@ -970,10 +970,10 @@ bool DistributedChatService::locked_initLobbyBouncableObject(const ChatLobbyId& // now sign the object, if the lobby expects it - uint32_t size = item.signed_serial_size() ; + uint32_t size = item.serial_size_no_signature() ; RsTemporaryMemory memory(size) ; - if(!item.serialise_signed_part(memory,size)) + if(!item.serialize_no_signature(memory,size)) { std::cerr << "(EE) Cannot sign message item. " << std::endl; return false ; diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index aa0a19cda..165dc94de 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -35,6 +35,8 @@ //#define CHAT_DEBUG 1 +static const uint32_t RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE = 0x0001; + #ifdef TO_BE_REMOVED std::ostream& RsChatMsgItem::print(std::ostream &out, uint16_t indent) { @@ -474,7 +476,7 @@ bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize) } #endif -void RsChatLobbyBouncingObject::serial_process_special(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature) +void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::TlvString tt(nick,TLV_TYPE_STR_NAME) ; @@ -482,7 +484,7 @@ void RsChatLobbyBouncingObject::serial_process_special(RsItem::SerializeJob j,Se RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; RsTypeSerializer::serial_process(j,ctx,tt ,"nick") ; - if(include_signature) + if(!(ctx.mFlags & RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE)) RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; } @@ -490,17 +492,9 @@ void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& { RsChatMsgItem::serial_process(j,ctx) ; - if(j == RsItem::SERIALIZE) - { - SerializeContext ctx2(NULL,0) ; - serial_process(RsItem::SIZE_ESTIMATE,ctx2); - - setRsItemHeader(ctx.mData, ctx.mSize, PacketId(), ctx2.mOffset); // correct header! - } - RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; - RsChatLobbyBouncingObject::serial_process_special(j,ctx,true) ; + RsChatLobbyBouncingObject::serial_process(j,ctx) ; } #ifdef TO_BE_REMOVED @@ -536,7 +530,6 @@ bool RsChatLobbyMsgItem::serialise(void *data, uint32_t& pktsize) #endif return ok ; } -#endif /* serialise the data to the buffer */ bool RsChatLobbyMsgItem::serialise_signed_part(void *data, uint32_t& pktsize) @@ -571,6 +564,7 @@ bool RsChatLobbyMsgItem::serialise_signed_part(void *data, uint32_t& pktsize) #endif return ok ; } +#endif void RsChatLobbyListRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { @@ -592,17 +586,17 @@ bool RsChatLobbyListRequestItem::serialise(void *data, uint32_t& pktsize) } #endif -template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,VisibleChatLobbyInfo& info) +template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,VisibleChatLobbyInfo& info) { RsTypeSerializer::serial_process(info.id) ; TlvString tt1(info.name ,TLV_TYPE_STR_NAME) ; TlvString tt2(info.topic,TLV_TYPE_STR_NAME) ; - RsTypeSerializer::serial_process(info.name) ; - RsTypeSerializer::serial_process(info.topic) ; - RsTypeSerializer::serial_process(info.count) ; - RsTypeSerializer::serial_process(info.flags.toUInt32()) ; + RsTypeSerializer::serial_process(j,ctx,info.name,"info.name") ; + RsTypeSerializer::serial_process(j,ctx,info.topic,"info.topic") ; + RsTypeSerializer::serial_process(j,ctx,info.count,"info.count") ; + RsTypeSerializer::serial_process(j,ctx,info.flags.toUInt32(),"info.flags") ; } void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) @@ -642,6 +636,18 @@ bool RsChatLobbyListItem::serialise(void *data, uint32_t& pktsize) } #endif +void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::TlvString tt(string1,TLV_TYPE_STR_NAME) ; + + RsTypeSerializer::serial_process(j,ctx,event_type,"event_type") ; + RsTypeSerializer::serial_process (j,ctx,string1,"string1") ; + RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; + + RsChatLobbyBouncingObject::serial_process(j,ctx,!(ctx.mFlags & RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE)); +} + +#ifdef TO_BE_REMOVED bool RsChatLobbyEventItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -702,6 +708,7 @@ bool RsChatLobbyEventItem::serialise_signed_part(void *data, uint32_t& pktsize) #endif return ok ; } +#endif void RsChatLobbyUnsubscribeItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { @@ -771,7 +778,7 @@ void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeConte { RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; - TlvString s(message,TLV_TYPE_STR_NAME) ; + RsTypeSerializer::TlvString s(lobby_name,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,s,"lobby_name") ; RsTypeSerializer::serial_process(j,ctx,lobby_flags.toUInt32(),"lobby_flags") ; @@ -809,7 +816,7 @@ bool RsChatLobbyInviteItem::serialise(void *data, uint32_t& pktsize) void RsPrivateChatMsgConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { uint32_t x=0 ; - TlvString s(message,TLV_TYPE_STR_MSG) ; + RsTypeSerializer::TlvString s(message,TLV_TYPE_STR_MSG) ; RsTypeSerializer::serial_process(j,ctx,x,"place holder value") ; RsTypeSerializer::serial_process (j,ctx,configPeerId,"configPeerId") ; @@ -956,7 +963,7 @@ bool RsChatStatusItem::serialise(void *data, uint32_t& pktsize) void RsChatAvatarItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::serial_process(j,ctx,RsTypeSerializer::BinaryDataBlock(data,image_size)) ; + RsTypeSerializer::serial_process(j,ctx,RsTypeSerializer::BinaryDataBlock_ref(image_data,image_size)) ; } #ifdef TO_BE_REMOVED @@ -1004,7 +1011,7 @@ bool RsChatAvatarItem::serialise(void *data, uint32_t& pktsize) void RsChatLobbyConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::serial_process(j,ctx,lobby_Id,"lobby_Id") ; + RsTypeSerializer::serial_process(j,ctx,lobby_Id,"lobby_Id") ; RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; } @@ -1134,7 +1141,6 @@ RsChatLobbyListItem::RsChatLobbyListItem(void *data,uint32_t) if (!ok) std::cerr << "Unknown error while deserializing." << std::endl ; } -#endif bool RsChatLobbyBouncingObject::deserialise_from_memory(void *data,uint32_t rssize,uint32_t& offset) { @@ -1172,7 +1178,6 @@ RsChatLobbyEventItem::RsChatLobbyEventItem(void *data,uint32_t /*size*/) std::cerr << "Unknown error while deserializing." << std::endl ; } -#ifdef TO_BE_REMOVED RsChatLobbyUnsubscribeItem::RsChatLobbyUnsubscribeItem(void *data,uint32_t /*size*/) : RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_UNSUBSCRIBE) { @@ -1393,3 +1398,43 @@ RsChatAvatarItem::RsChatAvatarItem(void *data,uint32_t /*size*/) #endif +uint32_t RsChatLobbyBouncingObject::serial_size_no_signature() const +{ + SerializeContext ctx(NULL,0); + + ctx.mOffset = 8; + ctx.mFlags = RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE ; + + const_cast(this)->serial_process(RsItem::SERIALIZE,ctx) ; + + return ctx.mOffset ; +} + +bool RsChatLobbyBouncingObject::serialize_no_signature(uint8_t *data,uint32_t size) const +{ + SerializeContext ctx(data,0); + + uint32_t tlvsize = serial_size_no_signature() ; + + if(tlvsize > size) + throw std::runtime_error("Cannot serialise: not enough room.") ; + + if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) + { + std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; + return false ; + } + ctx.mOffset = 8; + ctx.mSize = tlvsize; + ctx.mFlags = RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE ; + + const_cast(this)->serial_process(RsItem::SERIALIZE,ctx) ; + + if(ctx.mSize != ctx.mOffset) + { + std::cerr << "RsChatSerializer::serialise_item(): ERROR. offset does not match expected size!" << std::endl; + return false ; + } + return true ; +} + diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 3b04b995c..5cdee927e 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -137,17 +137,17 @@ public: virtual RsChatLobbyBouncingObject *duplicate() const = 0 ; - // returns the size in bytes of the data chunk to sign. - - virtual uint32_t signed_serial_size() =0; - virtual bool serialise_signed_part(void *data,uint32_t& size) = 0; + uint32_t serial_size_no_signature() const ; + bool serialize_no_signature(uint8_t *data,uint32_t size) const ; protected: // The functions below handle the serialisation of data that is specific to the bouncing object level. // They are called by serial_size() and serialise() from children, but should not overload the serial_size() and // serialise() methods, otherwise the wrong method will be called when serialising from this top level class. - void serial_process_special(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + + virtual uint32_t PacketId() const= 0; }; class RsChatLobbyMsgItem: public RsChatMsgItem, public RsChatLobbyBouncingObject @@ -160,10 +160,10 @@ public: void serial_process(RsItem::SerializeJob j,SerializeContext& ctx) ; - virtual uint32_t signed_serial_size() ; - virtual bool serialise_signed_part(void *data,uint32_t& size) ;// Isn't it better that items can serialize themselves ? - ChatLobbyMsgId parent_msg_id ; // Used for threaded chat. + +protected: + virtual uint32_t PacketId() const { return RsChatMsgItem::PacketId() ; } }; class RsChatLobbyEventItem: public RsChatItem, public RsChatLobbyBouncingObject @@ -176,14 +176,14 @@ class RsChatLobbyEventItem: public RsChatItem, public RsChatLobbyBouncingObject // void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); - virtual uint32_t signed_serial_size() ; - virtual bool serialise_signed_part(void *data,uint32_t& size) ; - // members. // uint8_t event_type ; // used for defining the type of event. std::string string1; // used for any string uint32_t sendTime; // used to check for old looping messages + +protected: + virtual uint32_t PacketId() const { return RsChatItem::PacketId() ; } }; class RsChatLobbyListRequestItem: public RsChatItem @@ -243,7 +243,7 @@ class RsChatLobbyInviteItem: public RsChatItem { public: RsChatLobbyInviteItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE) {} - virtual ~RsChatLobbyInviteItem() {} + virtual ~RsChatLobbyInviteItem() {} void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); @@ -279,6 +279,7 @@ class RsPrivateChatMsgConfigItem: public RsChatItem std::string message; uint32_t recvTime; }; + class RsChatLobbyConfigItem: public RsChatItem { public: diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 49505fc78..348d18375 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -8,12 +8,13 @@ class SerializeContext public: SerializeContext(uint8_t *data,uint32_t size) - : mData(data),mSize(size),mOffset(0),mOk(true) {} + : mData(data),mSize(size),mOffset(0),mOk(true),mFlags(0) {} unsigned char *mData ; uint32_t mSize ; uint32_t mOffset ; bool mOk ; + uint32_t mFlags ; }; @@ -57,10 +58,10 @@ class RsTypeSerializer } protected: - template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member); - template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); - template static uint32_t serial_size(const T& /* member */); - template static void print_data(const std::string& name,const T& /* member */); + template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member); + template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); + template static uint32_t serial_size(const T& /* member */); + template static void print_data(const std::string& name,const T& /* member */); }; From 48688eae3f2a04a024e83bc25597683902f4870d Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 5 Apr 2017 10:27:12 +0200 Subject: [PATCH 12/94] progress in converting chat items to new serialization --- libretroshare/src/chat/rschatitems.cc | 26 +++--- libretroshare/src/chat/rschatitems.h | 2 +- .../src/serialization/rsserializer.cc | 1 + .../src/serialization/rstypeserializer.h | 84 ++++++++++++++++--- 4 files changed, 88 insertions(+), 25 deletions(-) diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 165dc94de..41291515e 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -476,7 +476,7 @@ bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize) } #endif -void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, SerializeContext& ctx, bool include_signature) { RsTypeSerializer::TlvString tt(nick,TLV_TYPE_STR_NAME) ; @@ -484,7 +484,7 @@ void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j,SerializeC RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; RsTypeSerializer::serial_process(j,ctx,tt ,"nick") ; - if(!(ctx.mFlags & RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE)) + if(include_signature) RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; } @@ -494,7 +494,7 @@ void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; - RsChatLobbyBouncingObject::serial_process(j,ctx) ; + RsChatLobbyBouncingObject::serial_process(j,ctx,true) ; } #ifdef TO_BE_REMOVED @@ -586,9 +586,9 @@ bool RsChatLobbyListRequestItem::serialise(void *data, uint32_t& pktsize) } #endif -template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,VisibleChatLobbyInfo& info) +template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,VisibleChatLobbyInfo& info,const std::string& name) { - RsTypeSerializer::serial_process(info.id) ; + RsTypeSerializer::serial_process(j,ctx,info.id,"info.id") ; TlvString tt1(info.name ,TLV_TYPE_STR_NAME) ; TlvString tt2(info.topic,TLV_TYPE_STR_NAME) ; @@ -596,12 +596,12 @@ template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,Serializ RsTypeSerializer::serial_process(j,ctx,info.name,"info.name") ; RsTypeSerializer::serial_process(j,ctx,info.topic,"info.topic") ; RsTypeSerializer::serial_process(j,ctx,info.count,"info.count") ; - RsTypeSerializer::serial_process(j,ctx,info.flags.toUInt32(),"info.flags") ; + RsTypeSerializer::serial_process(j,ctx,info.flags,"info.flags") ; } void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::serial_process(j,ctx,lobbies,"lobbies") ; + RsTypeSerializer::serial_process(j,ctx,lobbies,"lobbies") ; } #ifdef TO_BE_REMOVED @@ -644,7 +644,7 @@ void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContex RsTypeSerializer::serial_process (j,ctx,string1,"string1") ; RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; - RsChatLobbyBouncingObject::serial_process(j,ctx,!(ctx.mFlags & RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE)); + RsChatLobbyBouncingObject::serial_process(j,ctx,true) ; } #ifdef TO_BE_REMOVED @@ -781,7 +781,7 @@ void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeConte RsTypeSerializer::TlvString s(lobby_name,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,s,"lobby_name") ; - RsTypeSerializer::serial_process(j,ctx,lobby_flags.toUInt32(),"lobby_flags") ; + RsTypeSerializer::serial_process(j,ctx,lobby_flags,"lobby_flags") ; } #ifdef TO_BE_REMOVED @@ -963,7 +963,7 @@ bool RsChatStatusItem::serialise(void *data, uint32_t& pktsize) void RsChatAvatarItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::serial_process(j,ctx,RsTypeSerializer::BinaryDataBlock_ref(image_data,image_size)) ; + RsTypeSerializer::serial_process(j,ctx,RsTypeSerializer::block_ref(image_data,image_size),"image data") ; } #ifdef TO_BE_REMOVED @@ -1403,9 +1403,8 @@ uint32_t RsChatLobbyBouncingObject::serial_size_no_signature() const SerializeContext ctx(NULL,0); ctx.mOffset = 8; - ctx.mFlags = RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE ; - const_cast(this)->serial_process(RsItem::SERIALIZE,ctx) ; + const_cast(this)->serial_process(RsItem::SERIALIZE,ctx,false) ; return ctx.mOffset ; } @@ -1426,9 +1425,8 @@ bool RsChatLobbyBouncingObject::serialize_no_signature(uint8_t *data,uint32_t si } ctx.mOffset = 8; ctx.mSize = tlvsize; - ctx.mFlags = RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE ; - const_cast(this)->serial_process(RsItem::SERIALIZE,ctx) ; + const_cast(this)->serial_process(RsItem::SERIALIZE,ctx,false) ; if(ctx.mSize != ctx.mOffset) { diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 5cdee927e..2440722dd 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -145,7 +145,7 @@ protected: // They are called by serial_size() and serialise() from children, but should not overload the serial_size() and // serialise() methods, otherwise the wrong method will be called when serialising from this top level class. - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature); virtual uint32_t PacketId() const= 0; }; diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index b17785038..745dc3521 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -2,6 +2,7 @@ #include "util/rsprint.h" #include "serialization/rsserializer.h" +#include "serialization/rstypeserializer.h" RsItem *RsSerializer::deserialise(const uint8_t *data,uint32_t size) { diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 348d18375..15bb8c696 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -1,5 +1,7 @@ #pragma once +#include + #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" @@ -8,31 +10,39 @@ class SerializeContext public: SerializeContext(uint8_t *data,uint32_t size) - : mData(data),mSize(size),mOffset(0),mOk(true),mFlags(0) {} + : mData(data),mSize(size),mOffset(0),mOk(true) {} unsigned char *mData ; uint32_t mSize ; uint32_t mOffset ; bool mOk ; - uint32_t mFlags ; }; class RsTypeSerializer { +protected: + class BinaryDataBlock_ref + { + public: + BinaryDataBlock_ref(unsigned char *_mem,uint32_t& _size) : mem(_mem),size(_size){} + + // This allows to pass Temporary objects as modifiable. This is valid only because all members of this class + // are pointers and references. + + BinaryDataBlock_ref& modifiable() const { return *const_cast(this) ; } + + unsigned char *& mem ; + uint32_t& size ; + }; + + public: // This type should be used to pass a parameter to drive the serialisation if needed. typedef std::pair TlvString; - class BinaryDataBlock_ref - { - public: - BinaryDataBlock_ref(unsigned char *& _mem,uint32_t& _size) : mem(&_mem),size(&_size){} - - unsigned char **mem ; - uint32_t *size ; - }; + static BinaryDataBlock_ref& block_ref(unsigned char *mem,uint32_t& size) { return BinaryDataBlock_ref(mem,size).modifiable() ; } template static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member,const std::string& member_name) @@ -57,11 +67,65 @@ class RsTypeSerializer } } + // Arrays of stuff + + template + static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,std::vector& v,const std::string& member_name) + { + switch(j) + { + case RsItem::SIZE_ESTIMATE: + { + ctx.mOffset += 4 ; + for(uint32_t i=0;i static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member); template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); template static uint32_t serial_size(const T& /* member */); template static void print_data(const std::string& name,const T& /* member */); + + }; From 5b3e488b423cb8e0aae0f50af6b510fd5d4125ea Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 5 Apr 2017 16:53:20 +0200 Subject: [PATCH 13/94] fixed compilation --- libretroshare/src/chat/rschatitems.cc | 16 ++-- libretroshare/src/retroshare/rsids.h | 2 +- libretroshare/src/serialiser/rsserial.h | 2 +- .../src/serialization/rsserializer.h | 2 +- .../src/serialization/rstypeserializer.h | 79 +++++++++++++++++-- .../src/serialization/serial_test.cc | 10 ++- 6 files changed, 91 insertions(+), 20 deletions(-) diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 41291515e..9865ca411 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -593,10 +593,10 @@ template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,Serializ TlvString tt1(info.name ,TLV_TYPE_STR_NAME) ; TlvString tt2(info.topic,TLV_TYPE_STR_NAME) ; - RsTypeSerializer::serial_process(j,ctx,info.name,"info.name") ; - RsTypeSerializer::serial_process(j,ctx,info.topic,"info.topic") ; + RsTypeSerializer::serial_process(j,ctx,tt1,"info.name") ; + RsTypeSerializer::serial_process(j,ctx,tt2,"info.topic") ; RsTypeSerializer::serial_process(j,ctx,info.count,"info.count") ; - RsTypeSerializer::serial_process(j,ctx,info.flags,"info.flags") ; + RsTypeSerializer::serial_process(j,ctx,info.flags,"info.flags") ; } void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) @@ -641,8 +641,8 @@ void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContex RsTypeSerializer::TlvString tt(string1,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,event_type,"event_type") ; - RsTypeSerializer::serial_process (j,ctx,string1,"string1") ; - RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; + RsTypeSerializer::serial_process (j,ctx,tt ,"string1") ; + RsTypeSerializer::serial_process(j,ctx,sendTime ,"sendTime") ; RsChatLobbyBouncingObject::serial_process(j,ctx,true) ; } @@ -781,7 +781,7 @@ void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeConte RsTypeSerializer::TlvString s(lobby_name,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,s,"lobby_name") ; - RsTypeSerializer::serial_process(j,ctx,lobby_flags,"lobby_flags") ; + RsTypeSerializer::serial_process(j,ctx,lobby_flags,"lobby_flags") ; } #ifdef TO_BE_REMOVED @@ -913,7 +913,7 @@ bool RsPrivateChatDistantInviteConfigItem::serialise(void *data, uint32_t& pktsi void RsChatStatusItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; + RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; RsTypeSerializer::TlvString tt(status_string,TLV_TYPE_STR_MSG) ; @@ -1012,7 +1012,7 @@ bool RsChatAvatarItem::serialise(void *data, uint32_t& pktsize) void RsChatLobbyConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,lobby_Id,"lobby_Id") ; - RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; + RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; } #ifdef TO_BE_REMOVED diff --git a/libretroshare/src/retroshare/rsids.h b/libretroshare/src/retroshare/rsids.h index db842ab21..a412f0cf2 100644 --- a/libretroshare/src/retroshare/rsids.h +++ b/libretroshare/src/retroshare/rsids.h @@ -120,7 +120,7 @@ template c offset += SIZE_IN_BYTES ; return true ; } - bool deserialise(void *data,uint32_t pktsize,uint32_t& offset) + bool deserialise(const void *data,uint32_t pktsize,uint32_t& offset) { if(offset + SIZE_IN_BYTES > pktsize) return false ; diff --git a/libretroshare/src/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index 0abc63af6..722eec9ec 100644 --- a/libretroshare/src/serialiser/rsserial.h +++ b/libretroshare/src/serialiser/rsserial.h @@ -122,7 +122,7 @@ class RsItem: public RsMemoryManagement::SmallObject */ typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03, PRINT=0x04 } SerializeJob ; - virtual void serial_process(SerializeJob j,SerializeContext& ctx) + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) { std::cerr << "(EE) RsItem::serial_process() called by an item using new serialization classes, but not derived! " << std::endl; } diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 8c5539088..f5f815d52 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -17,7 +17,7 @@ class RsSerializer: public RsSerialType /*! create_item * should be overloaded to create the correct type of item depending on the data */ - virtual RsItem *create_item(uint16_t service, uint8_t item_sub_id) + virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) { return NULL ; } diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 15bb8c696..2bb269ef6 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -1,10 +1,11 @@ #pragma once -#include - #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" +#include "retroshare/rsflags.h" +#include "retroshare/rsids.h" + class SerializeContext { public: @@ -44,6 +45,10 @@ protected: static BinaryDataBlock_ref& block_ref(unsigned char *mem,uint32_t& size) { return BinaryDataBlock_ref(mem,size).modifiable() ; } + //=================================================================================================// + // Generic types // + //=================================================================================================// + template static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member,const std::string& member_name) { @@ -67,7 +72,9 @@ protected: } } - // Arrays of stuff + //=================================================================================================// + // std::vector // + //=================================================================================================// template static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,std::vector& v,const std::string& member_name) @@ -106,7 +113,7 @@ protected: if(v.empty()) std::cerr << " Empty array"<< std::endl; else - std::cerr << " Array of \"" << typeid(v[0]).name() << "\"" << " with " << v.size() << " elements:"; + std::cerr << " Array of " << v.size() << " elements:" << std::endl; for(uint32_t i=0;i types // + //=================================================================================================// + + template + static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,t_RsFlags32& v,const std::string& member_name) + { + switch(j) + { + case RsItem::SIZE_ESTIMATE: ctx.mOffset += 4 ; + break ; + + case RsItem::DESERIALIZE: + { + uint32_t n=0 ; + deserialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; + v = t_RsFlags32(n) ; + } + break ; + + case RsItem::SERIALIZE: + { + uint32_t n=v.toUInt32() ; + serialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; + } + break ; + + case RsItem::PRINT: + std::cerr << " Flags of type " << std::hex << N << " : " << v.toUInt32() << std::endl; + break ; + } + + } protected: template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member); @@ -125,7 +165,36 @@ protected: template static uint32_t serial_size(const T& /* member */); template static void print_data(const std::string& name,const T& /* member */); - + template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsGenericIdType& member); + template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsGenericIdType& member); + template static uint32_t serial_size(const t_RsGenericIdType& /* member */); + template static void print_data(const std::string& name,const t_RsGenericIdType& /* member */); }; +//=================================================================================================// +// t_RsGenericId<> // +//=================================================================================================// +template +bool RsTypeSerializer::serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsGenericIdType& member) +{ + return (*const_cast *>(&member)).serialise(data,size,offset) ; +} + +template +bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsGenericIdType& member) +{ + return member.deserialise(data,size,offset) ; +} + +template +uint32_t RsTypeSerializer::serial_size(const t_RsGenericIdType& member) +{ + return member.serial_size(); +} + +template +void RsTypeSerializer::print_data(const std::string& name,const t_RsGenericIdType& member) +{ + std::cerr << " [RsGenericId<" << std::hex << UNIQUE_IDENTIFIER << ">] : " << member << std::endl; +} diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc index 786fd1d88..67770ad87 100644 --- a/libretroshare/src/serialization/serial_test.cc +++ b/libretroshare/src/serialization/serial_test.cc @@ -3,6 +3,7 @@ // #include +#include #include "util/rsmemory.h" #include "util/rsprint.h" @@ -90,9 +91,9 @@ class RsTestItem: public RsItem str = "test string"; ts = time(NULL) ; - int_set.insert(lrand48()) ; - int_set.insert(lrand48()) ; - int_set.insert(lrand48()) ; + int_set.push_back(lrand48()) ; + int_set.push_back(lrand48()) ; + int_set.push_back(lrand48()) ; } // Derived from RsItem @@ -114,7 +115,7 @@ class RsTestItem: public RsItem private: std::string str ; uint64_t ts ; - std::set int_set ; + std::vector int_set ; friend int main(int argc,char *argv[]); }; @@ -148,6 +149,7 @@ class RsTestSerializer: public RsSerializer void check(const std::string& s1,const std::string& s2) { assert(s1 == s2) ; } void check(const uint64_t& s1,const uint64_t& s2) { assert(s1 == s2) ; } void check(const std::set& s1,const std::set& s2) { assert(s1 == s2) ; } +void check(const std::vector& s1,const std::vector& s2) { assert(s1 == s2) ; } int main(int argc,char *argv[]) { From a941136c0457975c477c398a2dbb16c67f216caf Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 5 Apr 2017 18:09:45 +0200 Subject: [PATCH 14/94] fixed a few bugs in new serialization --- libretroshare/src/chat/distantchat.cc | 6 +++--- libretroshare/src/serialiser/rsserial.cc | 1 + libretroshare/src/serialization/rsserializer.cc | 14 ++++++-------- libretroshare/src/serialization/rsserializer.h | 9 ++++----- 4 files changed, 14 insertions(+), 16 deletions(-) diff --git a/libretroshare/src/chat/distantchat.cc b/libretroshare/src/chat/distantchat.cc index 576e97efe..8bb8b8d17 100644 --- a/libretroshare/src/chat/distantchat.cc +++ b/libretroshare/src/chat/distantchat.cc @@ -92,7 +92,7 @@ bool DistantChatService::handleOutgoingItem(RsChatItem *item) uint32_t size = RsChatSerialiser().size(item) ; RsTemporaryMemory mem(size) ; - if(!RsChatSerialiser().serialise(item,mem,size)) + if(!RsChatSerialiser().serialise(item,mem,&size)) { std::cerr << "(EE) serialisation error. Something's really wrong!" << std::endl; return false; @@ -152,7 +152,7 @@ bool DistantChatService::acceptDataFromPeer(const RsGxsId& gxs_id,const RsGxsTun uint32_t size = RsChatSerialiser().size(item) ; RsTemporaryMemory mem(size) ; - if(!RsChatSerialiser().serialise(item,mem,size)) + if(!RsChatSerialiser().serialise(item,mem,&size)) { std::cerr << "(EE) serialisation error. Something's really wrong!" << std::endl; return false; @@ -218,7 +218,7 @@ void DistantChatService::receiveData(const RsGxsTunnelService::RsGxsTunnelId &tu contact.from_id = tinfo.source_gxs_id ; } - RsItem *item = RsChatSerialiser().deserialise(data,data_size) ; + RsItem *item = RsChatSerialiser().deserialise(data,&data_size) ; if(item != NULL) { diff --git a/libretroshare/src/serialiser/rsserial.cc b/libretroshare/src/serialiser/rsserial.cc index 549bdc42c..8624b5304 100644 --- a/libretroshare/src/serialiser/rsserial.cc +++ b/libretroshare/src/serialiser/rsserial.cc @@ -219,6 +219,7 @@ uint32_t RsSerialType::size(RsItem *) bool RsSerialType::serialise(RsItem */*item*/, void */*data*/, uint32_t */*size*/) { + std::cerr << "(EE) Empty method called for missing serialize() method in serializer class " << typeid(this).name() << std::endl; #ifdef RSSERIAL_DEBUG std::cerr << "RsSerialType::serialise()" << std::endl; #endif diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index 745dc3521..4cf03d133 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -1,10 +1,8 @@ -#pragma once - #include "util/rsprint.h" #include "serialization/rsserializer.h" #include "serialization/rstypeserializer.h" -RsItem *RsSerializer::deserialise(const uint8_t *data,uint32_t size) +RsItem *RsSerializer::deserialise(void *data, uint32_t *size) { uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; @@ -13,11 +11,11 @@ RsItem *RsSerializer::deserialise(const uint8_t *data,uint32_t size) if(!item) { std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; - std::cerr << "(EE) Data is: " << RsUtil::BinToHex(data,std::min(50u,size)) << ((size>50)?"...":"") << std::endl; + std::cerr << "(EE) Data is: " << RsUtil::BinToHex(static_cast(data),std::min(50u,*size)) << ((*size>50)?"...":"") << std::endl; return NULL ; } - SerializeContext ctx(const_cast(data),size); + SerializeContext ctx(const_cast(static_cast(data)),*size); ctx.mOffset = 8 ; item->serial_process(RsItem::DESERIALIZE, ctx) ; @@ -29,13 +27,13 @@ RsItem *RsSerializer::deserialise(const uint8_t *data,uint32_t size) return NULL ; } -bool RsSerializer::serialise(RsItem *item,uint8_t *const data,uint32_t size) +bool RsSerializer::serialise(RsItem *item,void *data,uint32_t *size) { - SerializeContext ctx(data,0); + SerializeContext ctx(static_cast(data),0); uint32_t tlvsize = this->size(item) ; - if(tlvsize > size) + if(tlvsize > *size) throw std::runtime_error("Cannot serialise: not enough room.") ; if(!setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize)) diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index f5f815d52..9c6259cf9 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -12,7 +12,7 @@ class RsSerializer: public RsSerialType { public: - RsSerializer(uint16_t service_id) : RsSerialType(service_id) {} + RsSerializer(uint16_t service_id) : RsSerialType(RS_PKT_VERSION_SERVICE,service_id) {} /*! create_item * should be overloaded to create the correct type of item depending on the data @@ -22,11 +22,10 @@ class RsSerializer: public RsSerialType return NULL ; } - // The following functions *should not* be overloaded. - // They are kept public in order to allow them to be called if needed. + // The following functions overload RsSerialType. They *should not* need to be further overloaded. - RsItem *deserialise(const uint8_t *data,uint32_t size) ; - bool serialise(RsItem *item,uint8_t *const data,uint32_t size) ; + RsItem *deserialise(void *data,uint32_t *size) ; + bool serialise(RsItem *item,void *data,uint32_t *size) ; uint32_t size(RsItem *item) ; void print(RsItem *item) ; }; From 6b4fdb42ae7a23250357d771f9cf28d581ea3058 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 5 Apr 2017 18:25:54 +0200 Subject: [PATCH 15/94] fixed bug in serialization --- libretroshare/src/chat/rschatitems.cc | 20 ++++++++++-------- .../src/serialization/rstypeserializer.h | 21 ++----------------- 2 files changed, 13 insertions(+), 28 deletions(-) diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 9865ca411..ef4908252 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -254,7 +254,7 @@ RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) void RsChatMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::TlvString tt(message,TLV_TYPE_STR_MSG) ; + RsTypeSerializer::TlvString_proxy tt(message,TLV_TYPE_STR_MSG) ; RsTypeSerializer::serial_process(j,ctx,chatFlags,"chatflags") ; RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; @@ -478,7 +478,7 @@ bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize) void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, SerializeContext& ctx, bool include_signature) { - RsTypeSerializer::TlvString tt(nick,TLV_TYPE_STR_NAME) ; + RsTypeSerializer::TlvString_proxy tt(nick,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; @@ -590,8 +590,8 @@ template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,Serializ { RsTypeSerializer::serial_process(j,ctx,info.id,"info.id") ; - TlvString tt1(info.name ,TLV_TYPE_STR_NAME) ; - TlvString tt2(info.topic,TLV_TYPE_STR_NAME) ; + TlvString_proxy tt1(info.name ,TLV_TYPE_STR_NAME) ; + TlvString_proxy tt2(info.topic,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,tt1,"info.name") ; RsTypeSerializer::serial_process(j,ctx,tt2,"info.topic") ; @@ -638,7 +638,7 @@ bool RsChatLobbyListItem::serialise(void *data, uint32_t& pktsize) void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::TlvString tt(string1,TLV_TYPE_STR_NAME) ; + RsTypeSerializer::TlvString_proxy tt(string1,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,event_type,"event_type") ; RsTypeSerializer::serial_process (j,ctx,tt ,"string1") ; @@ -778,7 +778,7 @@ void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeConte { RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; - RsTypeSerializer::TlvString s(lobby_name,TLV_TYPE_STR_NAME) ; + RsTypeSerializer::TlvString_proxy s(lobby_name,TLV_TYPE_STR_NAME) ; RsTypeSerializer::serial_process(j,ctx,s,"lobby_name") ; RsTypeSerializer::serial_process(j,ctx,lobby_flags,"lobby_flags") ; @@ -816,7 +816,7 @@ bool RsChatLobbyInviteItem::serialise(void *data, uint32_t& pktsize) void RsPrivateChatMsgConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { uint32_t x=0 ; - RsTypeSerializer::TlvString s(message,TLV_TYPE_STR_MSG) ; + RsTypeSerializer::TlvString_proxy s(message,TLV_TYPE_STR_MSG) ; RsTypeSerializer::serial_process(j,ctx,x,"place holder value") ; RsTypeSerializer::serial_process (j,ctx,configPeerId,"configPeerId") ; @@ -915,7 +915,7 @@ void RsChatStatusItem::serial_process(RsItem::SerializeJob j,SerializeContext& c { RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; - RsTypeSerializer::TlvString tt(status_string,TLV_TYPE_STR_MSG) ; + RsTypeSerializer::TlvString_proxy tt(status_string,TLV_TYPE_STR_MSG) ; RsTypeSerializer::serial_process(j,ctx,tt,"status_string") ; } @@ -963,7 +963,9 @@ bool RsChatStatusItem::serialise(void *data, uint32_t& pktsize) void RsChatAvatarItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::serial_process(j,ctx,RsTypeSerializer::block_ref(image_data,image_size),"image data") ; + RsTypeSerializer::TlvMemBlock_proxy b(image_data,image_size) ; + + RsTypeSerializer::serial_process(j,ctx,b,"image data") ; } #ifdef TO_BE_REMOVED diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 2bb269ef6..f82365f82 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -22,28 +22,11 @@ class SerializeContext class RsTypeSerializer { -protected: - class BinaryDataBlock_ref - { - public: - BinaryDataBlock_ref(unsigned char *_mem,uint32_t& _size) : mem(_mem),size(_size){} - - // This allows to pass Temporary objects as modifiable. This is valid only because all members of this class - // are pointers and references. - - BinaryDataBlock_ref& modifiable() const { return *const_cast(this) ; } - - unsigned char *& mem ; - uint32_t& size ; - }; - - public: // This type should be used to pass a parameter to drive the serialisation if needed. - typedef std::pair TlvString; - - static BinaryDataBlock_ref& block_ref(unsigned char *mem,uint32_t& size) { return BinaryDataBlock_ref(mem,size).modifiable() ; } + typedef std::pair TlvString_proxy; + typedef std::pair TlvMemBlock_proxy; //=================================================================================================// // Generic types // From 03c31ceaccfe1812ea32765fa55cc573c6544159 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 5 Apr 2017 18:27:29 +0200 Subject: [PATCH 16/94] fixed serialization test example --- libretroshare/src/serialization/serial_test.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc index 67770ad87..a8d89a25f 100644 --- a/libretroshare/src/serialization/serial_test.cc +++ b/libretroshare/src/serialization/serial_test.cc @@ -100,7 +100,7 @@ class RsTestItem: public RsItem // virtual void serial_process(RsItem::SerializeJob j, SerializeContext& ctx) { - RsTypeSerializer::TlvString tt(str,TLV_TYPE_STR_DESCR) ; + RsTypeSerializer::TlvString_proxy tt(str,TLV_TYPE_STR_DESCR) ; RsTypeSerializer::serial_process(j,ctx,ts ,GET_VARIABLE_NAME(ts) ) ; RsTypeSerializer::serial_process(j,ctx,tt ,GET_VARIABLE_NAME(str) ) ; @@ -168,13 +168,13 @@ int main(int argc,char *argv[]) std::cerr << "Item to be serialized:" << std::endl; RsTestSerializer().print(&t1) ; - RsTestSerializer().serialise(&t1,mem1,mem1.size()) ; + RsTestSerializer().serialise(&t1,mem1,&size); std::cerr << "Serialized t1: " << RsUtil::BinToHex(mem1,mem1.size()) << std::endl; // Now deserialise into a new item // - RsItem *t2 = RsTestSerializer().deserialise(mem1,mem1.size()) ; + RsItem *t2 = RsTestSerializer().deserialise(mem1,&size); // make sure t1 is equal to t2 // From ae9d0b2ab48c7d0778385d680de728d104bb8762 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 5 Apr 2017 20:49:32 +0200 Subject: [PATCH 17/94] fixed a few bugs in chat serialization --- libretroshare/src/chat/distributedchat.cc | 10 +++---- libretroshare/src/chat/rschatitems.cc | 28 +++++++++++++------ libretroshare/src/chat/rschatitems.h | 33 ++++++++++++----------- 3 files changed, 43 insertions(+), 28 deletions(-) diff --git a/libretroshare/src/chat/distributedchat.cc b/libretroshare/src/chat/distributedchat.cc index 4d1207f8f..c83ddde8e 100644 --- a/libretroshare/src/chat/distributedchat.cc +++ b/libretroshare/src/chat/distributedchat.cc @@ -222,7 +222,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const mGixs->requestKey(obj->signature.keyId,peer_list,RsIdentityUsage(RS_SERVICE_TYPE_CHAT,RsIdentityUsage::CHAT_LOBBY_MSG_VALIDATION,RsGxsGroupId(),RsGxsMessageId(),obj->lobby_id)); - uint32_t size = obj->serial_size_no_signature() ; + uint32_t size = obj->serial_size_for_signature() ; RsTemporaryMemory memory(size) ; #ifdef DEBUG_CHAT_LOBBIES @@ -230,7 +230,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const std::cerr << " signature id: " << obj->signature.keyId << std::endl; #endif - if(!obj->serialize_no_signature(memory,size)) + if(!obj->serialize_for_signature(memory,size)) { std::cerr << " (EE) Cannot serialise message item. " << std::endl; return false ; @@ -239,7 +239,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const uint32_t error_status ; RsIdentityUsage use_info(RS_SERVICE_TYPE_CHAT,RsIdentityUsage::CHAT_LOBBY_MSG_VALIDATION,RsGxsGroupId(),RsGxsMessageId(),obj->lobby_id) ; - if(!mGixs->validateData(memory,obj->serial_size_no_signature(),obj->signature,false,use_info,error_status)) + if(!mGixs->validateData(memory,obj->serial_size_for_signature(),obj->signature,false,use_info,error_status)) { bool res = false ; @@ -970,10 +970,10 @@ bool DistributedChatService::locked_initLobbyBouncableObject(const ChatLobbyId& // now sign the object, if the lobby expects it - uint32_t size = item.serial_size_no_signature() ; + uint32_t size = item.serial_size_for_signature() ; RsTemporaryMemory memory(size) ; - if(!item.serialize_no_signature(memory,size)) + if(!item.serialize_for_signature(memory,size)) { std::cerr << "(EE) Cannot sign message item. " << std::endl; return false ; diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index ef4908252..e6a405c0c 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -491,12 +491,15 @@ void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, Serialize void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsChatMsgItem::serial_process(j,ctx) ; - RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; - RsChatLobbyBouncingObject::serial_process(j,ctx,true) ; } - +void RsChatLobbyMsgItem::serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsChatMsgItem::serial_process(j,ctx) ; + RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; + RsChatLobbyBouncingObject::serial_process(j,ctx,false) ; +} #ifdef TO_BE_REMOVED /* serialise the data to the buffer */ bool RsChatLobbyMsgItem::serialise(void *data, uint32_t& pktsize) @@ -646,7 +649,16 @@ void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContex RsChatLobbyBouncingObject::serial_process(j,ctx,true) ; } +void RsChatLobbyEventItem::serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::TlvString_proxy tt(string1,TLV_TYPE_STR_NAME) ; + RsTypeSerializer::serial_process(j,ctx,event_type,"event_type") ; + RsTypeSerializer::serial_process (j,ctx,tt ,"string1") ; + RsTypeSerializer::serial_process(j,ctx,sendTime ,"sendTime") ; + + RsChatLobbyBouncingObject::serial_process(j,ctx,false) ; +} #ifdef TO_BE_REMOVED bool RsChatLobbyEventItem::serialise(void *data, uint32_t& pktsize) { @@ -1400,22 +1412,22 @@ RsChatAvatarItem::RsChatAvatarItem(void *data,uint32_t /*size*/) #endif -uint32_t RsChatLobbyBouncingObject::serial_size_no_signature() const +uint32_t RsChatLobbyBouncingObject::serial_size_for_signature() const { SerializeContext ctx(NULL,0); ctx.mOffset = 8; - const_cast(this)->serial_process(RsItem::SERIALIZE,ctx,false) ; + const_cast(this)->serial_process_for_signature(RsItem::SIZE_ESTIMATE,ctx) ; return ctx.mOffset ; } -bool RsChatLobbyBouncingObject::serialize_no_signature(uint8_t *data,uint32_t size) const +bool RsChatLobbyBouncingObject::serialize_for_signature(uint8_t *data,uint32_t size) const { SerializeContext ctx(data,0); - uint32_t tlvsize = serial_size_no_signature() ; + uint32_t tlvsize = serial_size_for_signature() ; if(tlvsize > size) throw std::runtime_error("Cannot serialise: not enough room.") ; @@ -1428,7 +1440,7 @@ bool RsChatLobbyBouncingObject::serialize_no_signature(uint8_t *data,uint32_t si ctx.mOffset = 8; ctx.mSize = tlvsize; - const_cast(this)->serial_process(RsItem::SERIALIZE,ctx,false) ; + const_cast(this)->serial_process_for_signature(RsItem::SERIALIZE,ctx) ; if(ctx.mSize != ctx.mOffset) { diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 2440722dd..974dda91d 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -137,15 +137,16 @@ public: virtual RsChatLobbyBouncingObject *duplicate() const = 0 ; - uint32_t serial_size_no_signature() const ; - bool serialize_no_signature(uint8_t *data,uint32_t size) const ; + uint32_t serial_size_for_signature() const ; + bool serialize_for_signature(uint8_t *data,uint32_t size) const ; protected: // The functions below handle the serialisation of data that is specific to the bouncing object level. // They are called by serial_size() and serialise() from children, but should not overload the serial_size() and // serialise() methods, otherwise the wrong method will be called when serialising from this top level class. - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature); + virtual void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature); + virtual void serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx)=0; virtual uint32_t PacketId() const= 0; }; @@ -159,6 +160,7 @@ public: virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyMsgItem(*this) ; } void serial_process(RsItem::SerializeJob j,SerializeContext& ctx) ; + void serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) ; // This one is new, and used to add/remove signature on demand ChatLobbyMsgId parent_msg_id ; // Used for threaded chat. @@ -168,22 +170,23 @@ protected: class RsChatLobbyEventItem: public RsChatItem, public RsChatLobbyBouncingObject { - public: - RsChatLobbyEventItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_EVENT) {} +public: + RsChatLobbyEventItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_EVENT) {} - virtual ~RsChatLobbyEventItem() {} - virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyEventItem(*this) ; } - // - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + virtual ~RsChatLobbyEventItem() {} + virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyEventItem(*this) ; } + // + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) ; // This one is new, and used to add/remove signature on demand - // members. - // - uint8_t event_type ; // used for defining the type of event. - std::string string1; // used for any string - uint32_t sendTime; // used to check for old looping messages + // members. + // + uint8_t event_type ; // used for defining the type of event. + std::string string1; // used for any string + uint32_t sendTime; // used to check for old looping messages protected: - virtual uint32_t PacketId() const { return RsChatItem::PacketId() ; } + virtual uint32_t PacketId() const { return RsChatItem::PacketId() ; } }; class RsChatLobbyListRequestItem: public RsChatItem From 8b773885fddb0a48c843effa1cbe326a34349c67 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 5 Apr 2017 21:02:17 +0200 Subject: [PATCH 18/94] removed all chat serialization code --- libretroshare/src/chat/rschatitems.cc | 1189 ------------------------- libretroshare/src/chat/rschatitems.h | 24 - 2 files changed, 1213 deletions(-) diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index e6a405c0c..f7edf5601 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -37,196 +37,6 @@ static const uint32_t RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE = 0x0001; -#ifdef TO_BE_REMOVED -std::ostream& RsChatMsgItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsChatMsgItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "QblogMs " << chatFlags << std::endl; - - printIndent(out, int_Indent); - out << "sendTime: " << sendTime << " (" << time(NULL)-sendTime << " secs ago)" << std::endl; - - printIndent(out, int_Indent); - - std::string cnv_message(message.begin(), message.end()); - out << "msg: " << cnv_message << std::endl; - - printRsItemEnd(out, "RsChatMsgItem", indent); - return out; -} - -std::ostream& RsChatLobbyListItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsChatLobbyListItem", indent); - - for(uint32_t i=0;i void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,VisibleChatLobbyInfo& info,const std::string& name) { RsTypeSerializer::serial_process(j,ctx,info.id,"info.id") ; @@ -607,38 +130,6 @@ void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext RsTypeSerializer::serial_process(j,ctx,lobbies,"lobbies") ; } -#ifdef TO_BE_REMOVED -bool RsChatLobbyListItem::serialise(void *data, uint32_t& pktsize) -{ - uint32_t tlvsize = serial_size() ; - bool ok = true ; - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); // correct header! - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize ; - - uint32_t offset = 8 ; - ok &= setRawUInt32(data, tlvsize, &offset, lobbies.size()); - - for(uint32_t i=0;i(j,ctx,lobby_id,"lobby_id") ; } -#ifdef TO_BE_REMOVED -bool RsChatLobbyUnsubscribeItem::serialise(void *data, uint32_t& pktsize) -{ - uint32_t tlvsize = serial_size() ; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - bool ok = true ; - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); // correct header! - uint32_t offset = 8 ; - - ok &= setRawUInt64(data, tlvsize, &offset, lobby_id); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl; - } -#ifdef CHAT_DEBUG - std::cerr << "computed size: " << 256*((unsigned char*)data)[6]+((unsigned char*)data)[7] << std::endl ; -#endif - pktsize = tlvsize ; - return ok ; -} -#endif - void RsChatLobbyConnectChallengeItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,challenge_code,"challenge_code") ; } -#ifdef TO_BE_REMOVED -bool RsChatLobbyConnectChallengeItem::serialise(void *data, uint32_t& pktsize) -{ - uint32_t tlvsize = serial_size() ; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - bool ok = true ; - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); // correct header! - uint32_t offset = 8 ; - - ok &= setRawUInt64(data, tlvsize, &offset, challenge_code); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl; - } -#ifdef CHAT_DEBUG - std::cerr << "computed size: " << 256*((unsigned char*)data)[6]+((unsigned char*)data)[7] << std::endl ; -#endif - pktsize = tlvsize ; - return ok ; -} -#endif - void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; - RsTypeSerializer::TlvString_proxy s(lobby_name,TLV_TYPE_STR_NAME) ; - RsTypeSerializer::serial_process(j,ctx,s,"lobby_name") ; RsTypeSerializer::serial_process(j,ctx,lobby_flags,"lobby_flags") ; } -#ifdef TO_BE_REMOVED -bool RsChatLobbyInviteItem::serialise(void *data, uint32_t& pktsize) -{ - uint32_t tlvsize = serial_size() ; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - bool ok = true ; - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); // correct header! - uint32_t offset = 8 ; - - ok &= setRawUInt64(data, tlvsize, &offset, lobby_id); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, lobby_name); - ok &= setRawUInt32(data, tlvsize, &offset, lobby_flags.toUInt32()); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl; - } -#ifdef CHAT_DEBUG - std::cerr << "computed size: " << 256*((unsigned char*)data)[6]+((unsigned char*)data)[7] << std::endl ; -#endif - pktsize = tlvsize ; - return ok ; -} -#endif - void RsPrivateChatMsgConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { uint32_t x=0 ; @@ -838,505 +181,25 @@ void RsPrivateChatMsgConfigItem::serial_process(RsItem::SerializeJob j,Serialize RsTypeSerializer::serial_process(j,ctx,recvTime,"recvTime") ; } -#ifdef TO_BE_REMOVED -bool RsPrivateChatMsgConfigItem::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); - -#ifdef CHAT_DEBUG - std::cerr << "RsChatSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsChatSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, 0); - ok &= configPeerId.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, chatFlags); - ok &= setRawUInt32(data, tlvsize, &offset, configFlags); - ok &= setRawUInt32(data, tlvsize, &offset, sendTime); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, message); - ok &= setRawUInt32(data, tlvsize, &offset, recvTime); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl; - } - - return ok; -} - -bool RsPrivateChatDistantInviteConfigItem::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); - -#ifdef CHAT_DEBUG - std::cerr << "RsChatSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsChatSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= hash.serialise(data, tlvsize, offset) ; - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LINK, encrypted_radix64_string); - ok &= destination_pgp_id.serialise(data, tlvsize, offset); - - memcpy(&((unsigned char *)data)[offset],aes_key,16) ; - offset += 16 ; - - ok &= setRawUInt32(data, tlvsize, &offset, time_of_validity); - ok &= setRawUInt32(data, tlvsize, &offset, last_hit_time); - ok &= setRawUInt32(data, tlvsize, &offset, flags); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl; - } - - return ok; -} -#endif - void RsChatStatusItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; - RsTypeSerializer::TlvString_proxy tt(status_string,TLV_TYPE_STR_MSG) ; - RsTypeSerializer::serial_process(j,ctx,tt,"status_string") ; } -#ifdef TO_BE_REMOVED -bool RsChatStatusItem::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); - -#ifdef CHAT_DEBUG - std::cerr << "RsChatSerialiser serialising chat status item." << std::endl; - std::cerr << "RsChatSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsChatSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, flags); - ok &= SetTlvString(data, tlvsize, &offset,TLV_TYPE_STR_MSG, status_string); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl; - } -#ifdef CHAT_DEBUG - std::cerr << "computed size: " << 256*((unsigned char*)data)[6]+((unsigned char*)data)[7] << std::endl ; -#endif - - return ok; -} -#endif - void RsChatAvatarItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::TlvMemBlock_proxy b(image_data,image_size) ; - RsTypeSerializer::serial_process(j,ctx,b,"image data") ; } -#ifdef TO_BE_REMOVED -bool RsChatAvatarItem::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); - -#ifdef CHAT_DEBUG - std::cerr << "RsChatSerialiser serialising chat avatar item." << std::endl; - std::cerr << "RsChatSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsChatSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset,image_size); - - memcpy((void*)( (unsigned char *)data + offset),image_data,image_size) ; - offset += image_size ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl; - } -#ifdef CHAT_DEBUG - std::cerr << "computed size: " << 256*((unsigned char*)data)[6]+((unsigned char*)data)[7] << std::endl ; -#endif - - return ok; -} -#endif - void RsChatLobbyConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,lobby_Id,"lobby_Id") ; RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; } -#ifdef TO_BE_REMOVED -bool RsChatLobbyConfigItem::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); - -#ifdef CHAT_DEBUG - std::cerr << "RsChatLobbyConfigItem::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsChatLobbyConfigItem::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, lobby_Id); - ok &= setRawUInt32(data, tlvsize, &offset, flags ); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsChatLobbyConfigItem::serialise() Size Error! " << std::endl; - } - - return ok; -} - -RsChatMsgItem::RsChatMsgItem(void *data,uint32_t /*size*/,uint8_t subtype) - : RsChatItem(subtype) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - -#ifdef CHAT_DEBUG - std::cerr << "Received packet result: " ; - for(int i=0;i<20;++i) - std::cerr << (int)((uint8_t*)data)[i] << " " ; - std::cerr << std::endl ; -#endif - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &chatFlags); - ok &= getRawUInt32(data, rssize, &offset, &sendTime); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, message); - -#ifdef CHAT_DEBUG - std::cerr << "Building new chat msg item." << std::endl ; -#endif - if (getRsItemSubType(getRsItemId(data)) == RS_PKT_SUBTYPE_DEFAULT && offset != rssize) - std::cerr << "Size error while deserializing." << std::endl ; - if (!ok) - std::cerr << "Unknown error while deserializing." << std::endl ; -} - -RsChatLobbyMsgItem::RsChatLobbyMsgItem(void *data,uint32_t /*size*/) - : RsChatMsgItem(data,0,RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_MSG) -{ - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - uint32_t offset = RsChatMsgItem::serial_size() ; - - ok &= getRawUInt64(data, rssize, &offset, &parent_msg_id); - - ok &= RsChatLobbyBouncingObject::deserialise_from_memory(data,rssize,offset) ; - -#ifdef CHAT_DEBUG - std::cerr << "Building new chat lobby msg item." << std::endl ; -#endif - if (offset != rssize) - std::cerr << "Size error while deserializing." << std::endl ; - if (!ok) - std::cerr << "Unknown error while deserializing." << std::endl ; -} -RsChatLobbyListRequestItem::RsChatLobbyListRequestItem(void *data,uint32_t) - : RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_REQUEST) -{ - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - uint32_t offset = 8; // skip the header - - if (offset != rssize) - std::cerr << "Size error while deserializing." << std::endl ; - if (!ok) - std::cerr << "Unknown error while deserializing." << std::endl ; -} -RsChatLobbyListItem::RsChatLobbyListItem(void *data,uint32_t) - : RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_LIST) -{ - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - uint32_t offset = 8; // skip the header - - uint32_t n=0 ; - ok &= getRawUInt32(data, rssize, &offset, &n); - - lobbies.resize(n) ; - - for(uint32_t i=0;irecvTime = recvTime; } -#ifdef TO_BE_REMOVED -RsChatStatusItem::RsChatStatusItem(void *data,uint32_t /*size*/) - : RsChatItem(RS_PKT_SUBTYPE_CHAT_STATUS) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - -#ifdef CHAT_DEBUG - std::cerr << "Building new chat status item." << std::endl ; -#endif - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &flags); - ok &= GetTlvString(data, rssize, &offset,TLV_TYPE_STR_MSG, status_string); - - if (offset != rssize) - std::cerr << "Size error while deserializing." << std::endl ; - if (!ok) - std::cerr << "Unknown error while deserializing." << std::endl ; -} - -RsChatAvatarItem::RsChatAvatarItem(void *data,uint32_t /*size*/) - : RsChatItem(RS_PKT_SUBTYPE_CHAT_AVATAR) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - -#ifdef CHAT_DEBUG - std::cerr << "Building new chat status item." << std::endl ; -#endif - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset,&image_size); - - // ensure invalid image length does not overflow data - if( (offset + image_size) <= rssize){ - image_data = new unsigned char[image_size] ; - memcpy(image_data,(void*)((unsigned char*)data+offset),image_size) ; - offset += image_size ; - }else{ - ok = false; - std::cerr << "offset+image_size exceeds rssize" << std::endl; - } - - if (offset != rssize) - std::cerr << "Size error while deserializing." << std::endl ; - if (!ok) - std::cerr << "Unknown error while deserializing." << std::endl ; -} - -#endif - uint32_t RsChatLobbyBouncingObject::serial_size_for_signature() const { SerializeContext ctx(NULL,0); diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 974dda91d..7ec79ea44 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -327,30 +327,6 @@ class RsChatAvatarItem: public RsChatItem unsigned char *image_data ; // image }; -// This class contains the public Diffie-Hellman parameters to be sent -// when performing a DH agreement over a distant chat tunnel. -// -class RsChatDHPublicKeyItem: public RsChatItem -{ - public: - RsChatDHPublicKeyItem() :RsChatItem(RS_PKT_SUBTYPE_DISTANT_CHAT_DH_PUBLIC_KEY) {setPriorityLevel(QOS_PRIORITY_RS_CHAT_ITEM) ;} - - virtual ~RsChatDHPublicKeyItem() { BN_free(public_key) ; } - - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); - - // Private data to DH public key item - // - BIGNUM *public_key ; - - RsTlvKeySignature signature ; // signs the public key in a row. - RsTlvPublicRSAKey gxs_key ; // public key of the signer - - private: - RsChatDHPublicKeyItem(const RsChatDHPublicKeyItem&) : RsChatItem(RS_PKT_SUBTYPE_DISTANT_CHAT_DH_PUBLIC_KEY) {} // make the object non copy-able - const RsChatDHPublicKeyItem& operator=(const RsChatDHPublicKeyItem&) { return *this ;} -}; - class RsChatSerialiser: public RsSerializer { public: From 691ed8de08ae779531df638cfed874c5ea37ba99 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 10 Apr 2017 20:34:02 +0200 Subject: [PATCH 19/94] added new template for std::string with type id --- libretroshare/src/chat/rschatitems.cc | 50 +++++++------------ .../src/serialization/rstypeserializer.h | 33 +++++++++++- 2 files changed, 50 insertions(+), 33 deletions(-) diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index f7edf5601..a430b1119 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -64,11 +64,9 @@ RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) void RsChatMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::TlvString_proxy tt(message,TLV_TYPE_STR_MSG) ; - RsTypeSerializer::serial_process(j,ctx,chatFlags,"chatflags") ; RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; - RsTypeSerializer::serial_process(j,ctx,tt,"message") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,message,"message") ; } /*************************************************************************/ @@ -84,11 +82,9 @@ RsChatAvatarItem::~RsChatAvatarItem() void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, SerializeContext& ctx, bool include_signature) { - RsTypeSerializer::TlvString_proxy tt(nick,TLV_TYPE_STR_NAME) ; - RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; - RsTypeSerializer::serial_process(j,ctx,tt ,"nick") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_NAME,nick,"nick") ; if(include_signature) RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; @@ -116,13 +112,10 @@ template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,Serializ { RsTypeSerializer::serial_process(j,ctx,info.id,"info.id") ; - TlvString_proxy tt1(info.name ,TLV_TYPE_STR_NAME) ; - TlvString_proxy tt2(info.topic,TLV_TYPE_STR_NAME) ; - - RsTypeSerializer::serial_process(j,ctx,tt1,"info.name") ; - RsTypeSerializer::serial_process(j,ctx,tt2,"info.topic") ; - RsTypeSerializer::serial_process(j,ctx,info.count,"info.count") ; - RsTypeSerializer::serial_process(j,ctx,info.flags,"info.flags") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,info.name, "info.name") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,info.topic,"info.topic") ; + RsTypeSerializer::serial_process(j,ctx, info.count,"info.count") ; + RsTypeSerializer::serial_process (j,ctx, info.flags,"info.flags") ; } void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) @@ -132,20 +125,16 @@ void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::TlvString_proxy tt(string1,TLV_TYPE_STR_NAME) ; - RsTypeSerializer::serial_process(j,ctx,event_type,"event_type") ; - RsTypeSerializer::serial_process (j,ctx,tt ,"string1") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,string1,"string1") ; RsTypeSerializer::serial_process(j,ctx,sendTime ,"sendTime") ; RsChatLobbyBouncingObject::serial_process(j,ctx,true) ; } void RsChatLobbyEventItem::serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::TlvString_proxy tt(string1,TLV_TYPE_STR_NAME) ; - RsTypeSerializer::serial_process(j,ctx,event_type,"event_type") ; - RsTypeSerializer::serial_process (j,ctx,tt ,"string1") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,string1,"string1") ; RsTypeSerializer::serial_process(j,ctx,sendTime ,"sendTime") ; RsChatLobbyBouncingObject::serial_process(j,ctx,false) ; @@ -162,30 +151,27 @@ void RsChatLobbyConnectChallengeItem::serial_process(RsItem::SerializeJob j,Seri void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; - RsTypeSerializer::TlvString_proxy s(lobby_name,TLV_TYPE_STR_NAME) ; - RsTypeSerializer::serial_process(j,ctx,s,"lobby_name") ; - RsTypeSerializer::serial_process(j,ctx,lobby_flags,"lobby_flags") ; + RsTypeSerializer::serial_process(j,ctx, lobby_id, "lobby_id") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,lobby_name, "lobby_name") ; + RsTypeSerializer::serial_process (j,ctx, lobby_flags,"lobby_flags") ; } void RsPrivateChatMsgConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { uint32_t x=0 ; - RsTypeSerializer::TlvString_proxy s(message,TLV_TYPE_STR_MSG) ; - RsTypeSerializer::serial_process(j,ctx,x,"place holder value") ; - RsTypeSerializer::serial_process (j,ctx,configPeerId,"configPeerId") ; - RsTypeSerializer::serial_process(j,ctx,chatFlags,"chatFlags") ; - RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; - RsTypeSerializer::serial_process (j,ctx,s,"message") ; - RsTypeSerializer::serial_process(j,ctx,recvTime,"recvTime") ; + RsTypeSerializer::serial_process(j,ctx, x, "place holder value") ; + RsTypeSerializer::serial_process (j,ctx, configPeerId,"configPeerId") ; + RsTypeSerializer::serial_process(j,ctx, chatFlags, "chatFlags") ; + RsTypeSerializer::serial_process(j,ctx, sendTime, "sendTime") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_MSG,message, "message") ; + RsTypeSerializer::serial_process(j,ctx, recvTime, "recvTime") ; } void RsChatStatusItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; - RsTypeSerializer::TlvString_proxy tt(status_string,TLV_TYPE_STR_MSG) ; - RsTypeSerializer::serial_process(j,ctx,tt,"status_string") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,status_string,"status_string") ; } void RsChatAvatarItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index f82365f82..878ec3e6b 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -25,7 +25,6 @@ class RsTypeSerializer public: // This type should be used to pass a parameter to drive the serialisation if needed. - typedef std::pair TlvString_proxy; typedef std::pair TlvMemBlock_proxy; //=================================================================================================// @@ -55,6 +54,33 @@ class RsTypeSerializer } } + //=================================================================================================// + // Generic types + type_id // + //=================================================================================================// + + template + static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,uint16_t type_id,T& member,const std::string& member_name) + { + switch(j) + { + case RsItem::SIZE_ESTIMATE: ctx.mOffset += serial_size(type_id,member) ; + break ; + + case RsItem::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,type_id,member) ; + break ; + + case RsItem::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,type_id,member) ; + break ; + + case RsItem::PRINT: + print_data(member_name,type_id,member); + break; + default: + ctx.mOk = false ; + throw std::runtime_error("Unknown serial job") ; + } + } + //=================================================================================================// // std::vector // //=================================================================================================// @@ -148,6 +174,11 @@ class RsTypeSerializer template static uint32_t serial_size(const T& /* member */); template static void print_data(const std::string& name,const T& /* member */); + template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, uint16_t type_id,const T& member); + template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset,uint16_t type_id, T& member); + template static uint32_t serial_size(uint16_t type_id,const T& /* member */); + template static void print_data(const std::string& name,uint16_t type_id,const T& /* member */); + template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsGenericIdType& member); template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsGenericIdType& member); template static uint32_t serial_size(const t_RsGenericIdType& /* member */); From 731e20d0a3ed023f845dc618fea21c391411edb6 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 10 Apr 2017 22:09:56 +0200 Subject: [PATCH 20/94] switch BanListItem classes to new serialization system --- .../src/serialiser/rsbanlistitems.cc | 299 ++---------------- libretroshare/src/serialiser/rsbanlistitems.h | 44 +-- libretroshare/src/serialiser/rsbaseserial.cc | 23 +- libretroshare/src/serialiser/rsbaseserial.h | 14 +- libretroshare/src/serialiser/rsserial.h | 7 +- .../src/serialization/rstypeserializer.h | 36 ++- 6 files changed, 93 insertions(+), 330 deletions(-) diff --git a/libretroshare/src/serialiser/rsbanlistitems.cc b/libretroshare/src/serialiser/rsbanlistitems.cc index b22c16d2b..a110ec00f 100644 --- a/libretroshare/src/serialiser/rsbanlistitems.cc +++ b/libretroshare/src/serialiser/rsbanlistitems.cc @@ -25,7 +25,8 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rsbanlistitems.h" -#include "serialiser/rstlvbanlist.h" + +#include "serialization/rstypeserializer.h" /*** #define RSSERIAL_DEBUG 1 @@ -35,300 +36,36 @@ /*************************************************************************/ -RsBanListItem::~RsBanListItem() -{ - return; -} - void RsBanListItem::clear() { peerList.TlvClear(); } -std::ostream &RsBanListItem::print(std::ostream &out, uint16_t indent) +void RsBanListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - printRsItemBase(out, "RsBanListItem", indent); - uint16_t int_Indent = indent + 2; - peerList.print(out, int_Indent); - - printRsItemEnd(out, "RsBanListItem", indent); - return out; + RsTypeSerializer::serial_process(j,ctx,peerList,"peerList") ; } - -uint32_t RsBanListSerialiser::sizeList(RsBanListItem *item) +void RsBanListConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - uint32_t s = 8; /* header */ - s += item->peerList.TlvSize(); - - return s; + RsTypeSerializer::serial_process(j,ctx,type,"type") ; + RsTypeSerializer::serial_process (j,ctx,peerId,"peerId") ; + RsTypeSerializer::serial_process (j,ctx,update_time,"update_time") ; + RsTypeSerializer::serial_process (j,ctx,banned_peers,"banned_peers") ; } - -uint32_t RsBanListSerialiser::sizeListConfig(RsBanListConfigItem *item) +RsItem *RsBanListSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) { - uint32_t s = 8; /* header */ - s += 4 ; // type - s += item->banned_peers.TlvSize(); - s += 8 ; // update time - s += item->peerId.serial_size() ; + if(service_id != RS_SERVICE_TYPE_BANLIST) + return NULL ; - return s; -} -/* serialise the data to the buffer */ -bool RsBanListSerialiser::serialiseList(RsBanListItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeList(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsDsdvSerialiser::serialiseRoute() Header: " << ok << std::endl; - std::cerr << "RsDsdvSerialiser::serialiseRoute() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->peerList.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsDsdvSerialiser::serialiseRoute() Size Error! " << std::endl; -#endif - } - - return ok; -} -/* serialise the data to the buffer */ -bool RsBanListSerialiser::serialiseListConfig(RsBanListConfigItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeListConfig(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsBanListSerialiser::serialiseRoute() Header: " << ok << std::endl; - std::cerr << "RsBanListSerialiser::serialiseRoute() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - ok &= setRawUInt32(data, tlvsize, &offset,item->type); - ok &= item->peerId.serialise(data, tlvsize, offset); - ok &= setRawTimeT(data, tlvsize, &offset,item->update_time); - - /* add mandatory parts first */ - ok &= item->banned_peers.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) + switch(item_sub_id) { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsBanListSerialiser::serialiseRoute() Size Error! " << std::endl; -#endif - } - - return ok; -} -RsBanListItem *RsBanListSerialiser::deserialiseList(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t tlvsize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_BANLIST != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_BANLIST_ITEM != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < tlvsize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = tlvsize; - - bool ok = true; - - /* ready to load */ - RsBanListItem *item = new RsBanListItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->peerList.GetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} -RsBanListConfigItem *RsBanListSerialiser::deserialiseListConfig(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t tlvsize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_BANLIST != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < tlvsize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = tlvsize; - - bool ok = true; - - /* ready to load */ - RsBanListConfigItem *item = new RsBanListConfigItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - ok &= getRawUInt32(data, tlvsize, &offset,&item->type); - ok &= item->peerId.deserialise(data, tlvsize, offset); - ok &= getRawTimeT(data, tlvsize, &offset,item->update_time); - - /* add mandatory parts first */ - ok &= item->banned_peers.GetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ - -uint32_t RsBanListSerialiser::size(RsItem *i) -{ - RsBanListItem *dri; - RsBanListConfigItem *drc; - - if (NULL != (dri = dynamic_cast(i))) - { - return sizeList(dri); - } - - if (NULL != (drc = dynamic_cast(i))) - { - return sizeListConfig(drc); - } - return 0; -} - -bool RsBanListSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsBanListItem *dri; - RsBanListConfigItem *drc; - - if (NULL != (dri = dynamic_cast(i))) - { - return serialiseList(dri, data, pktsize); - } - if (NULL != (drc = dynamic_cast(i))) - { - return serialiseListConfig(drc, data, pktsize); - } - return false; -} - -RsItem *RsBanListSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_BANLIST != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_BANLIST_ITEM: - return deserialiseList(data, pktsize); - break; - case RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM: - return deserialiseListConfig(data, pktsize); - break; - default: - return NULL; - break; + case RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM: return new RsBanListConfigItem ; + case RS_PKT_SUBTYPE_BANLIST_ITEM: return new RsBanListItem ; + default: + std::cerr << "(EE) unknown item subtype " << (int)item_sub_id << " in RsBanListSerialiser::create_item()" << std::endl; + return NULL ; } } -void RsBanListConfigItem::clear() -{ - banned_peers.TlvClear() ; -} - -std::ostream &RsBanListConfigItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsBanListConfigItem", indent); - uint16_t int_Indent = indent + 2; - banned_peers.print(out, int_Indent); - - printRsItemEnd(out, "RsBanListConfigItem", indent); - return out; -} - -/*************************************************************************/ - - diff --git a/libretroshare/src/serialiser/rsbanlistitems.h b/libretroshare/src/serialiser/rsbanlistitems.h index 372f71a5d..cd5cb8cec 100644 --- a/libretroshare/src/serialiser/rsbanlistitems.h +++ b/libretroshare/src/serialiser/rsbanlistitems.h @@ -29,12 +29,12 @@ #include #include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" #include "serialiser/rstlvbanlist.h" +#include "serialization/rsserializer.h" #define RS_PKT_SUBTYPE_BANLIST_ITEM_deprecated 0x01 -#define RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM_deprecated 0x02 -#define RS_PKT_SUBTYPE_BANLIST_ITEM 0x03 +#define RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM_deprecated 0x02 +#define RS_PKT_SUBTYPE_BANLIST_ITEM 0x03 #define RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM 0x04 /**************************************************************************/ @@ -42,17 +42,15 @@ class RsBanListItem: public RsItem { public: - RsBanListItem() - :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST, - RS_PKT_SUBTYPE_BANLIST_ITEM) + RsBanListItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST, RS_PKT_SUBTYPE_BANLIST_ITEM) { setPriorityLevel(QOS_PRIORITY_RS_BANLIST_ITEM); return; } - virtual ~RsBanListItem(); + virtual ~RsBanListItem(){} virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); RsTlvBanList peerList; }; @@ -64,40 +62,22 @@ public: :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST, RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM) {} virtual ~RsBanListConfigItem(){} - virtual void clear(); + virtual void clear() { banned_peers.TlvClear() ; } - std::ostream &print(std::ostream &out, uint16_t indent = 0); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); uint32_t type ; RsPeerId peerId ; - time_t update_time ; + time_t update_time ; RsTlvBanList banned_peers; }; -class RsBanListSerialiser: public RsSerialType +class RsBanListSerialiser: public RsSerializer { public: - RsBanListSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST) - { return; } - virtual ~RsBanListSerialiser() - { return; } - - virtual uint32_t size(RsItem *); - virtual bool serialise (RsItem *item, void *data, uint32_t *size); - virtual RsItem * deserialise(void *data, uint32_t *size); - -private: - - virtual uint32_t sizeList(RsBanListItem *); - virtual bool serialiseList (RsBanListItem *item, void *data, uint32_t *size); - virtual RsBanListItem *deserialiseList(void *data, uint32_t *size); - - virtual uint32_t sizeListConfig(RsBanListConfigItem *); - virtual bool serialiseListConfig (RsBanListConfigItem *item, void *data, uint32_t *size); - virtual RsBanListConfigItem *deserialiseListConfig(void *data, uint32_t *size); - + RsBanListSerialiser() :RsSerializer(RS_SERVICE_TYPE_BANLIST) {} + virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) ; }; /**************************************************************************/ diff --git a/libretroshare/src/serialiser/rsbaseserial.cc b/libretroshare/src/serialiser/rsbaseserial.cc index 2ef67cd5b..44bd249d1 100644 --- a/libretroshare/src/serialiser/rsbaseserial.cc +++ b/libretroshare/src/serialiser/rsbaseserial.cc @@ -35,7 +35,7 @@ /* UInt8 get/set */ -bool getRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t *out) +bool getRawUInt8(const void *data, uint32_t size, uint32_t *offset, uint8_t *out) { /* first check there is space */ if (size < *offset + 1) @@ -71,7 +71,7 @@ bool setRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t in) } /* UInt16 get/set */ -bool getRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t *out) +bool getRawUInt16(const void *data, uint32_t size, uint32_t *offset, uint16_t *out) { /* first check there is space */ if (size < *offset + 2) @@ -113,7 +113,7 @@ bool setRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t in) /* UInt32 get/set */ -bool getRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t *out) +bool getRawUInt32(const void *data, uint32_t size, uint32_t *offset, uint32_t *out) { /* first check there is space */ if (size < *offset + 4) @@ -155,7 +155,7 @@ bool setRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t in) /* UInt64 get/set */ -bool getRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t *out) +bool getRawUInt64(const void *data, uint32_t size, uint32_t *offset, uint64_t *out) { /* first check there is space */ if (size < *offset + 8) @@ -195,7 +195,7 @@ bool setRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t in) return true; } -bool getRawUFloat32(void *data,uint32_t size,uint32_t *offset,float& f) +bool getRawUFloat32(const void *data, uint32_t size, uint32_t *offset, float& f) { uint32_t n ; if(!getRawUInt32(data, size, offset, &n) ) @@ -208,6 +208,13 @@ bool getRawUFloat32(void *data,uint32_t size,uint32_t *offset,float& f) bool setRawUFloat32(void *data,uint32_t size,uint32_t *offset,float f) { + uint32_t sz = 4; + + if ( !data || size <= *offset || size < sz + *offset ) + { + std::cerr << "(EE) not enough room. SIZE+offset=" << sz+*offset << " and size is only " << size << std::endl; + return false; + } if(f < 0.0f) { std::cerr << "(EE) Cannot serialise invalid negative float value " << f << " in " << __PRETTY_FUNCTION__ << std::endl; @@ -229,7 +236,7 @@ uint32_t getRawStringSize(const std::string &outStr) return outStr.length() + 4; } -bool getRawString(void *data, uint32_t size, uint32_t *offset, std::string &outStr) +bool getRawString(const void *data, uint32_t size, uint32_t *offset, std::string &outStr) { #warning Gio: "I had to change this. It seems like a bug to not clear the string. Should make sure it's not introducing any side effect." outStr.clear(); @@ -284,7 +291,7 @@ bool setRawString(void *data, uint32_t size, uint32_t *offset, const std::string return true; } -bool getRawTimeT(void *data,uint32_t size,uint32_t *offset,time_t& t) +bool getRawTimeT(const void *data,uint32_t size,uint32_t *offset,time_t& t) { uint64_t T ; bool res = getRawUInt64(data,size,offset,&T) ; @@ -292,7 +299,7 @@ bool getRawTimeT(void *data,uint32_t size,uint32_t *offset,time_t& t) return res ; } -bool setRawTimeT(void *data,uint32_t size,uint32_t *offset,const time_t& t) +bool setRawTimeT(void *data, uint32_t size, uint32_t *offset, const time_t& t) { return setRawUInt64(data,size,offset,t) ; } diff --git a/libretroshare/src/serialiser/rsbaseserial.h b/libretroshare/src/serialiser/rsbaseserial.h index 25e0f57cc..650fc9e6d 100644 --- a/libretroshare/src/serialiser/rsbaseserial.h +++ b/libretroshare/src/serialiser/rsbaseserial.h @@ -48,27 +48,27 @@ * ******************************************************************/ -bool getRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t *out); +bool getRawUInt8(const void *data, uint32_t size, uint32_t *offset, uint8_t *out); bool setRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t in); -bool getRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t *out); +bool getRawUInt16(const void *data, uint32_t size, uint32_t *offset, uint16_t *out); bool setRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t in); -bool getRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t *out); +bool getRawUInt32(const void *data, uint32_t size, uint32_t *offset, uint32_t *out); bool setRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t in); -bool getRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t *out); +bool getRawUInt64(const void *data, uint32_t size, uint32_t *offset, uint64_t *out); bool setRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t in); -bool getRawUFloat32(void *data, uint32_t size, uint32_t *offset, float& out); +bool getRawUFloat32(const void *data, uint32_t size, uint32_t *offset, float& out); bool setRawUFloat32(void *data, uint32_t size, uint32_t *offset, float in); uint32_t getRawStringSize(const std::string &outStr); -bool getRawString(void *data, uint32_t size, uint32_t *offset, std::string &outStr); +bool getRawString(const void *data, uint32_t size, uint32_t *offset, std::string &outStr); bool setRawString(void *data, uint32_t size, uint32_t *offset, const std::string &inStr); +bool getRawTimeT(const void *data, uint32_t size, uint32_t *offset, time_t& outStr); bool setRawTimeT(void *data, uint32_t size, uint32_t *offset, const time_t& inStr); -bool getRawTimeT(void *data, uint32_t size, uint32_t *offset, time_t& outStr); #endif diff --git a/libretroshare/src/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index 722eec9ec..21e0fcec7 100644 --- a/libretroshare/src/serialiser/rsserial.h +++ b/libretroshare/src/serialiser/rsserial.h @@ -84,7 +84,12 @@ class RsItem: public RsMemoryManagement::SmallObject virtual ~RsItem(); virtual void clear() = 0; - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0) = 0; + virtual std::ostream &print(std::ostream &out, uint16_t indent = 0) + { + std::cerr << "(EE) RsItem::print() called by an item using new serialization classes, but not derived! " << std::endl; +#warning This method should normally call serial_process(PRINT,ctx) + return out; + } void print_string(std::string &out, uint16_t indent = 0); /* source / destination id */ diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 878ec3e6b..349689c0b 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -2,6 +2,7 @@ #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" +#include "serialiser/rstlvlist.h" #include "retroshare/rsflags.h" #include "retroshare/rsids.h" @@ -183,6 +184,11 @@ class RsTypeSerializer template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsGenericIdType& member); template static uint32_t serial_size(const t_RsGenericIdType& /* member */); template static void print_data(const std::string& name,const t_RsGenericIdType& /* member */); + + template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsTlvList& member); + template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsTlvList& member); + template static uint32_t serial_size(const t_RsTlvList& /* member */); + template static void print_data(const std::string& name,const t_RsTlvList& /* member */); }; //=================================================================================================// @@ -208,7 +214,35 @@ uint32_t RsTypeSerializer::serial_size(const t_RsGenericIdType -void RsTypeSerializer::print_data(const std::string& name,const t_RsGenericIdType& member) +void RsTypeSerializer::print_data(const std::string& /* name */,const t_RsGenericIdType& member) { std::cerr << " [RsGenericId<" << std::hex << UNIQUE_IDENTIFIER << ">] : " << member << std::endl; } + +//=================================================================================================// +// t_RsTlvList<> // +//=================================================================================================// + +template +bool RsTypeSerializer::serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsTlvList& member) +{ + return (*const_cast *>(&member)).SetTlv(data,size,&offset) ; +} + +template +bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsTlvList& member) +{ + return member.GetTlv(const_cast(data),size,&offset) ; +} + +template +uint32_t RsTypeSerializer::serial_size(const t_RsTlvList& member) +{ + return member.TlvSize(); +} + +template +void RsTypeSerializer::print_data(const std::string& /* name */,const t_RsTlvList& member) +{ + std::cerr << " [t_RsTlvString<" << std::hex << TLV_TYPE << ">] : size=" << member.mList.size() << std::endl; +} From 80e8769ed7cfe068533695ebab52bf9e92574f6d Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 11 Apr 2017 21:37:35 +0200 Subject: [PATCH 21/94] added missign file and converted BW control items --- libretroshare/src/serialiser/rsbwctrlitems.cc | 34 +-- libretroshare/src/serialiser/rsbwctrlitems.h | 44 ++- .../src/serialization/rstypeserializer.cc | 254 ++++++++++++++++++ 3 files changed, 284 insertions(+), 48 deletions(-) create mode 100644 libretroshare/src/serialization/rstypeserializer.cc diff --git a/libretroshare/src/serialiser/rsbwctrlitems.cc b/libretroshare/src/serialiser/rsbwctrlitems.cc index fbd314bb2..bd1f0341e 100644 --- a/libretroshare/src/serialiser/rsbwctrlitems.cc +++ b/libretroshare/src/serialiser/rsbwctrlitems.cc @@ -34,9 +34,17 @@ /*************************************************************************/ -RsBwCtrlAllowedItem::~RsBwCtrlAllowedItem() +RsItem *RsBwCtrlSerialiser::create_item(uint16_t service, uint8_t item_sub_id) { - return; + if(service != RS_SERVICE_TYPE_BWCTRL) + return NULL ; + + switch(item_sub_id) + { + case RS_PKT_SUBTYPE_BWCTRL_ALLOWED_ITEM: return new RsBwCtrlAllowedItem(); + default: + return NULL; + } } void RsBwCtrlAllowedItem::clear() @@ -44,27 +52,12 @@ void RsBwCtrlAllowedItem::clear() allowedBw = 0; } -std::ostream &RsBwCtrlAllowedItem::print(std::ostream &out, uint16_t indent) +void RsBwCtrlAllowedItem::serial_process(SerializeJob j,SerializeContext& ctx) { - printRsItemBase(out, "RsBwCtrlAllowedItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "AllowedBw: " << allowedBw; - out << std::endl; - - printRsItemEnd(out, "RsBwCtrlAllowedItem", indent); - return out; -} - - -uint32_t RsBwCtrlSerialiser::sizeAllowed(RsBwCtrlAllowedItem * /*item*/) -{ - uint32_t s = 8; /* header */ - s += GetTlvUInt32Size(); - - return s; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_UINT32_BW,allowedBw,"allowedBw") ; } +#ifdef TO_REMOVE /* serialise the data to the buffer */ bool RsBwCtrlSerialiser::serialiseAllowed(RsBwCtrlAllowedItem *item, void *data, uint32_t *pktsize) { @@ -200,6 +193,7 @@ RsItem *RsBwCtrlSerialiser::deserialise(void *data, uint32_t *pktsize) } /*************************************************************************/ +#endif diff --git a/libretroshare/src/serialiser/rsbwctrlitems.h b/libretroshare/src/serialiser/rsbwctrlitems.h index c1679c9c9..8b5cc8299 100644 --- a/libretroshare/src/serialiser/rsbwctrlitems.h +++ b/libretroshare/src/serialiser/rsbwctrlitems.h @@ -32,50 +32,38 @@ #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" +#include "serialization/rsserializer.h" +#include "serialization/rstypeserializer.h" + #define RS_PKT_SUBTYPE_BWCTRL_ALLOWED_ITEM 0x01 /**************************************************************************/ class RsBwCtrlAllowedItem: public RsItem { - public: - RsBwCtrlAllowedItem() - :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BWCTRL, - RS_PKT_SUBTYPE_BWCTRL_ALLOWED_ITEM) - { +public: + RsBwCtrlAllowedItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BWCTRL, RS_PKT_SUBTYPE_BWCTRL_ALLOWED_ITEM) + { setPriorityLevel(QOS_PRIORITY_RS_BWCTRL_ALLOWED_ITEM); - return; + return; } -virtual ~RsBwCtrlAllowedItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual ~RsBwCtrlAllowedItem() {} + virtual void clear(); - uint32_t allowedBw; // Units are bytes/sec => 4Gb/s; + void serial_process(SerializeJob j,SerializeContext& ctx); + uint32_t allowedBw; // Units are bytes/sec => 4Gb/s; }; -class RsBwCtrlSerialiser: public RsSerialType +class RsBwCtrlSerialiser: public RsSerializer { - public: - RsBwCtrlSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BWCTRL) - { return; } -virtual ~RsBwCtrlSerialiser() - { return; } - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - -virtual uint32_t sizeAllowed(RsBwCtrlAllowedItem *); -virtual bool serialiseAllowed (RsBwCtrlAllowedItem *item, void *data, uint32_t *size); -virtual RsBwCtrlAllowedItem *deserialiseAllowed(void *data, uint32_t *size); - +public: + RsBwCtrlSerialiser() :RsSerializer(RS_SERVICE_TYPE_BWCTRL) {} + virtual ~RsBwCtrlSerialiser() {} + RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */); }; /**************************************************************************/ diff --git a/libretroshare/src/serialization/rstypeserializer.cc b/libretroshare/src/serialization/rstypeserializer.cc new file mode 100644 index 000000000..fc9563fe6 --- /dev/null +++ b/libretroshare/src/serialization/rstypeserializer.cc @@ -0,0 +1,254 @@ +#include "serialization/rsserializer.h" +#include "serialization/rstypeserializer.h" + +#include "serialiser/rsbaseserial.h" +#include "serialiser/rstlvkeys.h" + +#include "util/rsprint.h" + +#include + +static const uint32_t MAX_SERIALIZED_ARRAY_SIZE = 500 ; + +#ifdef REMOVE +template T ntoh(T t) +{ + if(sizeof(T) == 8) return t; + if(sizeof(T) == 4) return ntohl(t) ; + if(sizeof(T) == 2) return ntohs(t) ; + if(sizeof(T) == 1) return t ; + + std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in ntoh<>" << std::endl; + return t; +} +template T hton(T t) +{ + if(sizeof(T) == 8) return t; + if(sizeof(T) == 4) return htonl(t) ; + if(sizeof(T) == 2) return htons(t) ; + if(sizeof(T) == 1) return t ; + + std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in hton<>" << std::endl; + return t; +} +#endif + +//=================================================================================================// +// Integer types // +//=================================================================================================// + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint8_t& member) +{ + return setRawUInt8(data,size,&offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint32_t& member) +{ + return setRawUInt32(data,size,&offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint64_t& member) +{ + return setRawUInt64(data,size,&offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const time_t& member) +{ + return setRawTimeT(data,size,&offset,member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint8_t& member) +{ + return getRawUInt8(data,size,&offset,&member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint32_t& member) +{ + return getRawUInt32(data,size,&offset,&member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint64_t& member) +{ + return getRawUInt64(data,size,&offset,&member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, time_t& member) +{ + return getRawTimeT(data,size,&offset,member); +} +template<> uint32_t RsTypeSerializer::serial_size(const uint8_t& /* member*/) +{ + return 1; +} +template<> uint32_t RsTypeSerializer::serial_size(const uint32_t& /* member*/) +{ + return 4; +} +template<> uint32_t RsTypeSerializer::serial_size(const uint64_t& /* member*/) +{ + return 8; +} +template<> uint32_t RsTypeSerializer::serial_size(const time_t& /* member*/) +{ + return 8; +} + +template<> void RsTypeSerializer::print_data(const std::string& n, const uint8_t & V) +{ + std::cerr << " [uint8_t ] " << n << ": " << V << std::endl; +} +template<> void RsTypeSerializer::print_data(const std::string& n, const uint16_t& V) +{ + std::cerr << " [uint16_t ] " << n << ": " << V << std::endl; +} +template<> void RsTypeSerializer::print_data(const std::string& n, const uint32_t& V) +{ + std::cerr << " [uint32_t ] " << n << ": " << V << std::endl; +} +template<> void RsTypeSerializer::print_data(const std::string& n, const uint64_t& V) +{ + std::cerr << " [uint64_t ] " << n << ": " << V << std::endl; +} +template<> void RsTypeSerializer::print_data(const std::string& n, const time_t& V) +{ + std::cerr << " [time_t ] " << n << ": " << V << " (" << time(NULL)-V << " secs ago)" << std::endl; +} + + +//=================================================================================================// +// FLoats // +//=================================================================================================// + +template<> uint32_t RsTypeSerializer::serial_size(const float&){ return 4; } + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t& offset, const float& f) +{ + return setRawUFloat32(data,size,&offset,f) ; +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, float& f) +{ + return getRawUFloat32(data,size,&offset,f) ; +} +template<> void RsTypeSerializer::print_data(const std::string& n, const float& V) +{ + std::cerr << " [float ] " << n << ": " << V << std::endl; +} + + +//=================================================================================================// +// TlvString with subtype // +//=================================================================================================// + +template<> uint32_t RsTypeSerializer::serial_size(uint16_t /* type_subtype */,const std::string& s) +{ + return GetTlvStringSize(s) ; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,uint16_t type_substring,const std::string& s) +{ + return SetTlvString(data,size,&offset,type_substring,s) ; +} + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,uint16_t type_substring,std::string& s) +{ + return GetTlvString((void*)data,size,&offset,type_substring,s) ; +} + +template<> void RsTypeSerializer::print_data(const std::string& n, uint16_t type_substring,const std::string& V) +{ + std::cerr << " [TlvString ] " << n << ": type=" << std::hex < uint32_t RsTypeSerializer::serial_size(uint16_t /* type_subtype */,const uint32_t& s) +{ + return GetTlvUInt32Size() ; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,uint16_t sub_type,const uint32_t& s) +{ + return SetTlvUInt32(data,size,&offset,sub_type,s) ; +} + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,uint16_t sub_type,uint32_t& s) +{ + return GetTlvUInt32((void*)data,size,&offset,sub_type,&s) ; +} + +template<> void RsTypeSerializer::print_data(const std::string& n, uint16_t sub_type,const uint32_t& V) +{ + std::cerr << " [TlvUInt32 ] " << n << ": type=" << std::hex < void RsTypeSerializer::print_data(const std::string& n, const std::string& V) +{ + std::cerr << " [std::string] " << n << ": " << V << std::endl; +} + +//=================================================================================================// +// Binary blocks // +//=================================================================================================// + +template<> uint32_t RsTypeSerializer::serial_size(const RsTypeSerializer::TlvMemBlock_proxy& r) { return 4 + r.second ; } + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[],uint32_t size,uint32_t& offset,RsTypeSerializer::TlvMemBlock_proxy& r) +{ + uint32_t saved_offset = offset ; + + bool ok = deserialize(data,size,offset,r.second) ; + + r.first = (uint8_t*)rs_malloc(r.second) ; + + ok = ok && NULL != r.first; + + memcpy(r.first,&data[offset],r.second) ; + + if(!ok) + offset = saved_offset ; + + return ok; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[],uint32_t size,uint32_t& offset,const RsTypeSerializer::TlvMemBlock_proxy& r) +{ + uint32_t saved_offset = offset ; + + bool ok = serialize(data,size,offset,r.second) ; + + memcpy(&data[offset],r.first,r.second) ; + + if(!ok) + offset = saved_offset ; + + return ok; +} + +template<> void RsTypeSerializer::print_data(const std::string& n, const RsTypeSerializer::TlvMemBlock_proxy& s) +{ + std::cerr << " [Binary data] " << n << ", length=" << s.second << " data=" << RsUtil::BinToHex(s.first,std::min(50u,s.second)) << ((s.second>50)?"...":"") << std::endl; +} + +//=================================================================================================// +// Signatures // +//=================================================================================================// + +template<> uint32_t RsTypeSerializer::serial_size(const RsTlvKeySignature& s) +{ + return s.TlvSize() ; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const RsTlvKeySignature& s) +{ + return s.SetTlv(data,size,&offset) ; +} + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,RsTlvKeySignature& s) +{ + return s.GetTlv((void*)data,size,&offset) ; +} + +template<> void RsTypeSerializer::print_data(const std::string& n, const RsTlvKeySignature& s) +{ + std::cerr << " [Signature] " << n << " : key_id=" << s.keyId << ", length=" << s.signData.bin_len << std::endl; +} From 3453a3e57dcddcd514a1be031cfd37a76a993790 Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 11 Apr 2017 23:05:27 +0200 Subject: [PATCH 22/94] switched FileTransfer items to new serialization --- libretroshare/src/chat/rschatitems.cc | 2 +- .../src/serialiser/rsfiletransferitems.cc | 765 ++---------------- .../src/serialiser/rsfiletransferitems.h | 103 +-- libretroshare/src/serialiser/rstlvfileitem.h | 2 +- .../src/serialization/rstypeserializer.cc | 60 +- 5 files changed, 110 insertions(+), 822 deletions(-) diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index a430b1119..88e7abe8a 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -87,7 +87,7 @@ void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, Serialize RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_NAME,nick,"nick") ; if(include_signature) - RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; + RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; } void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) diff --git a/libretroshare/src/serialiser/rsfiletransferitems.cc b/libretroshare/src/serialiser/rsfiletransferitems.cc index 0caabc2f8..0be0412b7 100644 --- a/libretroshare/src/serialiser/rsfiletransferitems.cc +++ b/libretroshare/src/serialiser/rsfiletransferitems.cc @@ -28,6 +28,8 @@ #include "serialiser/rstlvbase.h" #include "serialiser/rsfiletransferitems.h" +#include "serialization/rstypeserializer.h" + /*** * #define RSSERIAL_DEBUG 1 * #define DEBUG_TRANSFERS 1 @@ -40,758 +42,115 @@ #include -/**********************************************************************************************/ -/* SERIALISER STUFF */ -/**********************************************************************************************/ - -RsFileTransferItem *RsFileTransferSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if(RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemService(rstype)) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_FT_CACHE_ITEM: return deserialise_RsFileTransferCacheItem(data, *pktsize); - case RS_PKT_SUBTYPE_FT_DATA_REQUEST: return deserialise_RsFileTransferDataRequestItem(data, *pktsize); - case RS_PKT_SUBTYPE_FT_DATA: return deserialise_RsFileTransferDataItem(data, *pktsize); - case RS_PKT_SUBTYPE_FT_CHUNK_MAP_REQUEST: return deserialise_RsFileTransferChunkMapRequestItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_FT_CHUNK_MAP: return deserialise_RsFileTransferChunkMapItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_FT_CHUNK_CRC_REQUEST: return deserialise_RsFileTransferSingleChunkCrcRequestItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_FT_CHUNK_CRC: return deserialise_RsFileTransferSingleChunkCrcItem(data,*pktsize) ; - default: - std::cerr << "RsFileTransferSerialiser::deserialise(): Could not de-serialise item. SubPacket id = " << std::hex << getRsItemSubType(rstype) << " id = " << rstype << std::dec << std::endl; - return NULL; - } - return NULL; -} - -/**********************************************************************************************/ -/* OUTPUTS */ -/**********************************************************************************************/ - -std::ostream& RsFileTransferCacheItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileTransferCacheItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "CacheId: " << cacheType << "/" << cacheSubId << std::endl; - file.print(out, int_Indent); - printRsItemEnd(out, "RsFileTransferCacheItem", indent); - return out; -} -std::ostream& RsFileTransferDataRequestItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileTransferDataRequestItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "FileOffset: " << fileoffset; - out << " ChunkSize: " << chunksize << std::endl; - file.print(out, int_Indent); - printRsItemEnd(out, "RsFileTransferDataRequestItem", indent); - return out; -} -std::ostream& RsFileTransferChunkMapItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileTransferChunkMapItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); out << "PeerId: " << PeerId() << std::endl ; - printIndent(out, int_Indent); out << " hash: " << hash << std::endl ; - printIndent(out, int_Indent); out << "chunks: " << std::hex << compressed_map._map[0] << std::dec << "..." << std::endl ; - printRsItemEnd(out, "RsFileTransferChunkMapItem", indent); - return out; -} -std::ostream& RsFileTransferChunkMapRequestItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileTransferChunkMapRequestItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); out << "PeerId: " << PeerId() << std::endl ; - printIndent(out, int_Indent); out << " hash: " << hash << std::endl ; - printRsItemEnd(out, "RsFileTransferChunkMapRequestItem", indent); - return out; -} -std::ostream& RsFileTransferSingleChunkCrcRequestItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileTransferSingleChunkCrcRequestItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); out << "PeerId: " << PeerId() << std::endl ; - printIndent(out, int_Indent); out << " hash: " << hash << std::endl ; - printIndent(out, int_Indent); out << " chunk: " << chunk_number << "..." << std::endl ; - printRsItemEnd(out, "RsFileTransferSingleChunkCrcRequestItem", indent); - return out; -} -std::ostream& RsFileTransferSingleChunkCrcItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileTransferSingleChunkCrcItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); out << "PeerId: " << PeerId() << std::endl ; - printIndent(out, int_Indent); out << " hash: " << hash << std::endl ; - printIndent(out, int_Indent); out << " chunk: " << chunk_number << "..." << std::endl ; - printIndent(out, int_Indent); out << " sha1: " << check_sum.toStdString() << "..." << std::endl ; - printRsItemEnd(out, "RsFileTransferSingleChunkCrcItem", indent); - return out; -} -std::ostream& RsFileTransferDataItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileTransferDataItem", indent); - uint16_t int_Indent = indent + 2; - fd.print(out, int_Indent); - printRsItemEnd(out, "RsFileTransferDataItem", indent); - return out; -} - -/**********************************************************************************************/ -/* SERIAL SIZE */ -/**********************************************************************************************/ - -uint32_t RsFileTransferDataRequestItem::serial_size() -{ - uint32_t s = 8; /* header */ - s += 8; /* offset */ - s += 4; /* chunksize */ - s += file.TlvSize(); - - return s; -} -uint32_t RsFileTransferCacheItem::serial_size() -{ - uint32_t s = 8; /* header */ - s += 4; /* type/subid */ - s += file.TlvSize(); - - return s; -} -uint32_t RsFileTransferDataItem::serial_size() -{ - uint32_t s = 8; /* header */ - s += fd.TlvSize(); - - return s; -} -uint32_t RsFileTransferChunkMapRequestItem::serial_size() -{ - uint32_t s = 8; /* header */ - s += 1 ; // is_client - s += hash.serial_size() ; // hash - - return s; -} -uint32_t RsFileTransferChunkMapItem::serial_size() -{ - uint32_t s = 8; /* header */ - s += 1 ; // is_client - s += hash.serial_size() ; // hash - s += 4 ; // compressed map size - s += 4 * compressed_map._map.size() ; // compressed chunk map - - return s; -} -uint32_t RsFileTransferSingleChunkCrcItem::serial_size() -{ - uint32_t s = 8; /* header */ - s += hash.serial_size() ; // hash - s += 4 ; // chunk number - s += check_sum.serial_size() ; // sha1 - - return s; -} -uint32_t RsFileTransferSingleChunkCrcRequestItem::serial_size() -{ - uint32_t s = 8; /* header */ - s += hash.serial_size() ; // hash - s += 4 ; // chunk number - - return s; -} - -/*************************************************************************/ - void RsFileTransferDataRequestItem::clear() { file.TlvClear(); fileoffset = 0; chunksize = 0; } -void RsFileTransferCacheItem::clear() -{ - cacheType = 0; - cacheSubId = 0; - file.TlvClear(); -} void RsFileTransferDataItem::clear() { fd.TlvClear(); } -/**********************************************************************************************/ -/* SERIALISATION */ -/**********************************************************************************************/ - -bool RsFileTransferItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) +void RsFileTransferDataRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - tlvsize = serial_size() ; - offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsFileTransferItem::serialise_header(): ERROR. Not enough size!" << std::endl; - return false ; - } -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileItemSerialiser::serialiseData() Header: " << ok << std::endl; -#endif - offset += 8; - - return true ; + RsTypeSerializer::serial_process (j,ctx,fileoffset,"fileoffset") ; + RsTypeSerializer::serial_process (j,ctx,chunksize, "chunksize") ; + RsTypeSerializer::serial_process(j,ctx,file, "file") ; } -/* serialise the data to the buffer */ -bool RsFileTransferChunkMapRequestItem::serialise(void *data, uint32_t& pktsize) +void RsFileTransferDataItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt8(data, tlvsize, &offset, is_client); - ok &= hash.serialise(data, tlvsize, offset) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl; - } - - return ok; -} -bool RsFileTransferSingleChunkCrcRequestItem::serialise(void *data, uint32_t& pktsize) -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= hash.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, chunk_number) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl; - } - - return ok; -} -bool RsFileTransferSingleChunkCrcItem::serialise(void *data, uint32_t& pktsize) -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= hash.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, chunk_number) ; - - ok &= check_sum.serialise(data,tlvsize,offset) ; - - //ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[0]) ; - //ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[1]) ; - //ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[2]) ; - //ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[3]) ; - //ok &= setRawUInt32(data, tlvsize, &offset, check_sum.fourbytes[4]) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl; - } - - return ok; -} -bool RsFileTransferChunkMapItem::serialise(void *data, uint32_t& pktsize) -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt8(data, tlvsize, &offset, is_client); - ok &= hash.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, compressed_map._map.size()); - - for(uint32_t i=0;i(j,ctx,fd,"fd") ; } -/* serialise the data to the buffer */ -bool RsFileTransferDataItem::serialise(void *data, uint32_t& pktsize) +void RsFileTransferChunkMapRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= fd.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl; - } - -#ifdef DEBUG_TRANSFERS - std::cerr << "RsFileItemSerialiser::serialiseData() at: " << RsUtil::AccurateTimeString() << std::endl; - print(std::cerr, 10); -#endif - - return ok; + RsTypeSerializer::serial_process (j,ctx,is_client,"is_client") ; + RsTypeSerializer::serial_process (j,ctx,hash, "hash") ; } -/* serialise the data to the buffer */ -bool RsFileTransferDataRequestItem::serialise(void *data, uint32_t& pktsize) +void RsFileTransferChunkMapItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, fileoffset); - ok &= setRawUInt32(data, tlvsize, &offset, chunksize); - ok &= file.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsFileTransferDataRequestItem::serialise() Size Error! " << std::endl; - } - - /*** Debugging Transfer rates. - * print timestamp, and file details so we can workout packet lags. - ***/ - -#ifdef DEBUG_TRANSFERS - std::cerr << "RsFileTransferDataRequestItem::serialise() at: " << RsUtil::AccurateTimeString() << std::endl; - print(std::cerr, 10); -#endif - - return ok; + RsTypeSerializer::serial_process (j,ctx,is_client, "is_client") ; + RsTypeSerializer::serial_process (j,ctx,hash, "hash") ; + RsTypeSerializer::serial_process (j,ctx,compressed_map,"compressed_map") ; } -/* serialise the data to the buffer */ -bool RsFileTransferCacheItem::serialise(void *data, uint32_t& pktsize) +void RsFileTransferSingleChunkCrcRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt16(data, tlvsize, &offset, cacheType); - ok &= setRawUInt16(data, tlvsize, &offset, cacheSubId); - ok &= file.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileItemSerialiser::serialiseItem() Size Error! " << std::endl; -#endif - } - - return ok; + RsTypeSerializer::serial_process (j,ctx,hash, "hash") ; + RsTypeSerializer::serial_process(j,ctx,chunk_number,"chunk_number") ; } -/**********************************************************************************************/ -/* DESERIALISATION */ -/**********************************************************************************************/ - -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferCacheItem(void *data, uint32_t pktsize) +void RsFileTransferSingleChunkCrcItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if(RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CACHE_ITEM != getRsItemSubType(rstype)) - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferCacheItem(): wong subtype!" << std::endl; - return NULL; /* wrong type */ - } - - if (pktsize < rssize) /* check size */ - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferCacheItem(): size inconsistency!" << std::endl; - return NULL; /* not enough data */ - } - - bool ok = true; - - /* ready to load */ - RsFileTransferCacheItem *item = new RsFileTransferCacheItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt16(data, rssize, &offset, &(item->cacheType)); - ok &= getRawUInt16(data, rssize, &offset, &(item->cacheSubId)); - ok &= item->file.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; + RsTypeSerializer::serial_process (j,ctx,hash, "hash") ; + RsTypeSerializer::serial_process(j,ctx,chunk_number,"chunk_number") ; + RsTypeSerializer::serial_process (j,ctx,check_sum, "check_sum") ; } -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapRequestItem(void *data, uint32_t pktsize) +//===================================================================================================// +// CompressedChunkMap // +//===================================================================================================// + +template<> uint32_t RsTypeSerializer::serial_size(const CompressedChunkMap& s) { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if(RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CHUNK_MAP_REQUEST != getRsItemSubType(rstype)) - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapRequestItem(): wong subtype!" << std::endl; - return NULL; /* wrong type */ - } - - if (pktsize < rssize) /* check size */ - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapRequestItem(): size inconsistency!" << std::endl; - return NULL; /* not enough data */ - } - - bool ok = true; - - /* ready to load */ - RsFileTransferChunkMapRequestItem *item = new RsFileTransferChunkMapRequestItem(); - item->clear(); - - /* skip the header */ - offset += 8; - uint8_t tmp ; - ok &= getRawUInt8(data, rssize, &offset, &tmp); item->is_client = tmp; - ok &= item->hash.deserialise(data, rssize, offset) ; // File hash - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; + return 4 + 4*s._map.size() ; } -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferDataItem(void *data, uint32_t pktsize) +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const CompressedChunkMap& s) { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); + bool ok = true ; - uint32_t offset = 0; + ok &= setRawUInt32(data, size, &offset, s._map.size()); - if(RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_DATA != getRsItemSubType(rstype)) - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataItem(): wong subtype!" << std::endl; - return NULL; /* wrong type */ - } + for(uint32_t i=0;iclear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->fd.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - -#ifdef DEBUG_TRANSFERS - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataItem() at: " << RsUtil::AccurateTimeString() << std::endl; - item->print(std::cerr, 10); -#endif - - return item; + return ok; } - -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferDataRequestItem(void *data, uint32_t pktsize) +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,CompressedChunkMap& s) { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if (RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_DATA_REQUEST != getRsItemSubType(rstype)) - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataRequestItem(): wrong subtype!" << std::endl; - return NULL; /* wrong type */ - } - - if (pktsize < rssize) /* check size */ - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataRequestItem(): size inconsistency!" << std::endl; - return NULL; /* not enough data */ - } - - RsFileTransferDataRequestItem *item = new RsFileTransferDataRequestItem() ; - - bool ok = true; - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt64(data, rssize, &offset, &item->fileoffset); - ok &= getRawUInt32(data, rssize, &offset, &item->chunksize); - ok &= item->file.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - /*** Debugging Transfer rates. - * print timestamp, and file details so we can workout packet lags. - ***/ - -#ifdef DEBUG_TRANSFERS - std::cerr << "RsFileItemSerialiser::deserialise_RsFileTransferDataRequestItem() at: " << RsUtil::AccurateTimeString() << std::endl; - item->print(std::cerr, 10); -#endif - - return item; -} -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapItem(void *data, uint32_t pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if (RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CHUNK_MAP != getRsItemSubType(rstype)) - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapItem(): wrong subtype!" << std::endl; - return NULL; /* wrong type */ - } - - if (pktsize < rssize) /* check size */ - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapItem(): size inconsistency!" << std::endl; - return NULL; /* not enough data */ - } - - bool ok = true; - - /* ready to load */ - RsFileTransferChunkMapItem *item = new RsFileTransferChunkMapItem(); - item->clear(); - - /* skip the header */ - offset += 8; - uint8_t tmp ; - ok &= getRawUInt8(data, rssize, &offset, &tmp); item->is_client = tmp; - ok &= item->hash.deserialise(data, rssize, offset) ; // File hash - uint32_t size =0; - ok &= getRawUInt32(data, rssize, &offset, &size); + uint32_t S =0; + bool ok = getRawUInt32(data, size, &offset, &S); if(ok) { - item->compressed_map._map.resize(size) ; + s._map.resize(S) ; - for(uint32_t i=0;icompressed_map._map[i])); + for(uint32_t i=0;i void RsTypeSerializer::print_data(const std::string& n, const CompressedChunkMap& s) { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if (RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CHUNK_CRC_REQUEST != getRsItemSubType(rstype)) - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcRequestItem(): wrong subtype!" << std::endl; - return NULL; /* wrong type */ - } - - if (pktsize < rssize) /* check size */ - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcRequestItem(): size inconsistency!" << std::endl; - return NULL; /* not enough data */ - } - - bool ok = true; - - /* ready to load */ - RsFileTransferSingleChunkCrcRequestItem *item = new RsFileTransferSingleChunkCrcRequestItem(); - item->clear(); - - /* skip the header */ - offset += 8; - ok &= item->hash.deserialise(data, rssize, offset) ; - ok &= getRawUInt32(data, rssize, &offset, &(item->chunk_number)); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; + std::cerr << " [Compressed chunk map] " << n << " : length=" << s._map.size() << std::endl; } -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcItem(void *data, uint32_t pktsize) + +//===================================================================================================// +// Serializer // +//===================================================================================================// + +RsItem *RsFileTransferSerialiser::create_item(uint16_t service_type,uint8_t item_type) { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); + if(service_type != RS_SERVICE_TYPE_FILE_TRANSFER) + return NULL ; - uint32_t offset = 0; - - if (RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_FILE_TRANSFER != getRsItemType(rstype) || RS_PKT_SUBTYPE_FT_CHUNK_CRC != getRsItemSubType(rstype)) - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcItem(): wrong subtype!" << std::endl; - return NULL; /* wrong type */ - } - - if (pktsize < rssize) /* check size */ - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcItem(): size inconsistency!" << std::endl; - return NULL; /* not enough data */ - } - - bool ok = true; - - /* ready to load */ - RsFileTransferSingleChunkCrcItem *item = new RsFileTransferSingleChunkCrcItem(); - item->clear(); - - /* skip the header */ - offset += 8; - ok &= item->hash.deserialise(data, rssize, offset) ; - ok &= getRawUInt32(data, rssize, &offset, &(item->chunk_number)); - ok &= item->check_sum.deserialise(data,rssize,offset) ; - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; + switch(item_type) + { + case RS_PKT_SUBTYPE_FT_DATA_REQUEST : return new RsFileTransferDataRequestItem(); + case RS_PKT_SUBTYPE_FT_DATA : return new RsFileTransferDataItem(); + case RS_PKT_SUBTYPE_FT_CHUNK_MAP_REQUEST : return new RsFileTransferChunkMapRequestItem(); + case RS_PKT_SUBTYPE_FT_CHUNK_MAP : return new RsFileTransferChunkMapItem(); + case RS_PKT_SUBTYPE_FT_CHUNK_CRC_REQUEST : return new RsFileTransferSingleChunkCrcRequestItem(); + case RS_PKT_SUBTYPE_FT_CHUNK_CRC : return new RsFileTransferSingleChunkCrcItem() ; + default: + return NULL ; + } } -/*************************************************************************/ diff --git a/libretroshare/src/serialiser/rsfiletransferitems.h b/libretroshare/src/serialiser/rsfiletransferitems.h index fa989861d..50b3c2a26 100644 --- a/libretroshare/src/serialiser/rsfiletransferitems.h +++ b/libretroshare/src/serialiser/rsfiletransferitems.h @@ -29,10 +29,10 @@ #include "retroshare/rstypes.h" #include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" #include "serialiser/rstlvfileitem.h" #include "serialiser/rsserviceids.h" +#include "serialization/rsserializer.h" const uint8_t RS_PKT_SUBTYPE_FT_DATA_REQUEST = 0x01; const uint8_t RS_PKT_SUBTYPE_FT_DATA = 0x02; @@ -53,20 +53,11 @@ const uint8_t RS_PKT_SUBTYPE_FT_CACHE_REQUEST = 0x0B; class RsFileTransferItem: public RsItem { public: - RsFileTransferItem(uint8_t ft_subtype) - : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_FILE_TRANSFER,ft_subtype) - {} + RsFileTransferItem(uint8_t ft_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_FILE_TRANSFER,ft_subtype) {} virtual ~RsFileTransferItem() {} - virtual bool serialise(void *data,uint32_t& size) = 0 ; - virtual uint32_t serial_size() = 0 ; - - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0) = 0; virtual void clear() = 0 ; - - protected: - bool serialise_header(void *data, uint32_t& pktsize, uint32_t& tlvsize, uint32_t& offset) ; }; class RsFileTransferDataRequestItem: public RsFileTransferItem @@ -77,13 +68,9 @@ class RsFileTransferDataRequestItem: public RsFileTransferItem setPriorityLevel(QOS_PRIORITY_RS_FILE_REQUEST) ; } virtual ~RsFileTransferDataRequestItem() {} - - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; - virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); // Private data part. // @@ -103,11 +90,9 @@ class RsFileTransferDataItem: public RsFileTransferItem } virtual ~RsFileTransferDataItem() { clear() ; } - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; - virtual void clear(); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual void clear(); // Private data part. // @@ -122,10 +107,9 @@ class RsFileTransferChunkMapRequestItem: public RsFileTransferItem setPriorityLevel(QOS_PRIORITY_RS_FILE_MAP_REQUEST) ; } virtual ~RsFileTransferChunkMapRequestItem() {} - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; virtual void clear() {} - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); // Private data part. // @@ -142,11 +126,9 @@ class RsFileTransferChunkMapItem: public RsFileTransferItem setPriorityLevel(QOS_PRIORITY_RS_FILE_MAP) ; } virtual ~RsFileTransferChunkMapItem() {} - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; - virtual void clear() {} - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + virtual void clear() {} // Private data part. // @@ -163,11 +145,9 @@ class RsFileTransferSingleChunkCrcRequestItem: public RsFileTransferItem setPriorityLevel(QOS_PRIORITY_RS_CHUNK_CRC_REQUEST) ; } virtual ~RsFileTransferSingleChunkCrcRequestItem() {} - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; - virtual void clear() {} - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + virtual void clear() {} // Private data part. // @@ -183,11 +163,9 @@ class RsFileTransferSingleChunkCrcItem: public RsFileTransferItem setPriorityLevel(QOS_PRIORITY_RS_CHUNK_CRC) ; } virtual ~RsFileTransferSingleChunkCrcItem() {} - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; - virtual void clear() {} - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + virtual void clear() {} // Private data part. // @@ -196,65 +174,16 @@ class RsFileTransferSingleChunkCrcItem: public RsFileTransferItem Sha1CheckSum check_sum ; // CRC32 map of the file. }; -class RsFileTransferCacheItem: public RsFileTransferItem -{ - public: - RsFileTransferCacheItem() :RsFileTransferItem(RS_PKT_SUBTYPE_FT_CACHE_ITEM) - { - setPriorityLevel(QOS_PRIORITY_RS_CACHE_ITEM); - } - - virtual ~RsFileTransferCacheItem(){ clear() ; } - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); - - // private part. - // - uint16_t cacheType; - uint16_t cacheSubId; - RsTlvFileItem file; /* file information */ -}; - - /**************************************************************************/ -class RsFileTransferSerialiser: public RsSerialType +class RsFileTransferSerialiser: public RsSerializer { public: - RsFileTransferSerialiser(): RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_FILE_TRANSFER) {} + RsFileTransferSerialiser(): RsSerializer(RS_SERVICE_TYPE_FILE_TRANSFER) {} virtual ~RsFileTransferSerialiser() {} - virtual uint32_t size(RsItem *item) - { - RsFileTransferItem *ftitem = dynamic_cast(item); - if (!ftitem) - { - return 0; - } - return ftitem->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - RsFileTransferItem *ftitem = dynamic_cast(item); - if (!ftitem) - { - return false; - } - return ftitem->serialise(data,*size) ; - } - virtual RsFileTransferItem *deserialise(void *data, uint32_t *size); - - private: - RsFileTransferItem *deserialise_RsFileTransferCacheItem(void *data, uint32_t pktsize); - RsFileTransferItem *deserialise_RsFileTransferChunkMapRequestItem(void *data, uint32_t pktsize); - RsFileTransferItem *deserialise_RsFileTransferChunkMapItem(void *data, uint32_t pktsize); - RsFileTransferItem *deserialise_RsFileTransferDataRequestItem(void *data, uint32_t pktsize); - RsFileTransferItem *deserialise_RsFileTransferDataItem(void *data, uint32_t pktsize); - RsFileTransferItem *deserialise_RsFileTransferSingleChunkCrcItem(void *data, uint32_t pktsize); - RsFileTransferItem *deserialise_RsFileTransferSingleChunkCrcRequestItem(void *data, uint32_t pktsize); + RsItem *create_item(uint16_t service_type,uint8_t item_type) ; }; diff --git a/libretroshare/src/serialiser/rstlvfileitem.h b/libretroshare/src/serialiser/rstlvfileitem.h index 62745b658..1a474e60c 100644 --- a/libretroshare/src/serialiser/rstlvfileitem.h +++ b/libretroshare/src/serialiser/rstlvfileitem.h @@ -42,7 +42,7 @@ virtual ~RsTlvFileItem() { return; } virtual uint32_t TlvSize() const; virtual void TlvClear(); virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset) const; -virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); +virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); virtual std::ostream &print(std::ostream &out, uint16_t indent) const; uint64_t filesize; /// Mandatory: size of file to be downloaded diff --git a/libretroshare/src/serialization/rstypeserializer.cc b/libretroshare/src/serialization/rstypeserializer.cc index fc9563fe6..5a8def1bd 100644 --- a/libretroshare/src/serialization/rstypeserializer.cc +++ b/libretroshare/src/serialization/rstypeserializer.cc @@ -10,34 +10,15 @@ static const uint32_t MAX_SERIALIZED_ARRAY_SIZE = 500 ; -#ifdef REMOVE -template T ntoh(T t) -{ - if(sizeof(T) == 8) return t; - if(sizeof(T) == 4) return ntohl(t) ; - if(sizeof(T) == 2) return ntohs(t) ; - if(sizeof(T) == 1) return t ; - - std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in ntoh<>" << std::endl; - return t; -} -template T hton(T t) -{ - if(sizeof(T) == 8) return t; - if(sizeof(T) == 4) return htonl(t) ; - if(sizeof(T) == 2) return htons(t) ; - if(sizeof(T) == 1) return t ; - - std::cerr << "(EE) unhandled type of size " << sizeof(T) << " in hton<>" << std::endl; - return t; -} -#endif - //=================================================================================================// // Integer types // //=================================================================================================// -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint8_t& member) +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const bool& member) +{ + return setRawUInt8(data,size,&offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint8_t& member) { return setRawUInt8(data,size,&offset,member); } @@ -53,6 +34,14 @@ template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint3 { return setRawTimeT(data,size,&offset,member); } + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, bool& member) +{ + uint8_t m ; + bool ok = getRawUInt8(data,size,&offset,&m); + member = m ; + return ok; +} template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint8_t& member) { return getRawUInt8(data,size,&offset,&member); @@ -69,6 +58,11 @@ template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t siz { return getRawTimeT(data,size,&offset,member); } + +template<> uint32_t RsTypeSerializer::serial_size(const bool& /* member*/) +{ + return 1; +} template<> uint32_t RsTypeSerializer::serial_size(const uint8_t& /* member*/) { return 1; @@ -86,6 +80,10 @@ template<> uint32_t RsTypeSerializer::serial_size(const time_t& /* member*/) return 8; } +template<> void RsTypeSerializer::print_data(const std::string& n, const bool & V) +{ + std::cerr << " [bool ] " << n << ": " << V << std::endl; +} template<> void RsTypeSerializer::print_data(const std::string& n, const uint8_t & V) { std::cerr << " [uint8_t ] " << n << ": " << V << std::endl; @@ -230,25 +228,27 @@ template<> void RsTypeSerializer::print_data(const std::string& n, const RsTypeS } //=================================================================================================// -// Signatures // +// TlvItems // //=================================================================================================// -template<> uint32_t RsTypeSerializer::serial_size(const RsTlvKeySignature& s) +template<> uint32_t RsTypeSerializer::serial_size(const RsTlvItem& s) { return s.TlvSize() ; } -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const RsTlvKeySignature& s) +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const RsTlvItem& s) { return s.SetTlv(data,size,&offset) ; } -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,RsTlvKeySignature& s) +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,RsTlvItem& s) { return s.GetTlv((void*)data,size,&offset) ; } -template<> void RsTypeSerializer::print_data(const std::string& n, const RsTlvKeySignature& s) +template<> void RsTypeSerializer::print_data(const std::string& n, const RsTlvItem& s) { - std::cerr << " [Signature] " << n << " : key_id=" << s.keyId << ", length=" << s.signData.bin_len << std::endl; + // can we call TlvPrint inside this? + + std::cerr << " [" << typeid(s).name() << "] " << n << std::endl; } From 636450f14dcaf3bd934f659daa320f9b30491702 Mon Sep 17 00:00:00 2001 From: csoler Date: Sat, 15 Apr 2017 18:46:44 +0200 Subject: [PATCH 23/94] moved turtle and FT to new serialization --- libretroshare/src/ft/ftserver.cc | 32 +-- libretroshare/src/ft/ftserver.h | 4 +- .../src/ft/ftturtlefiletransferitem.cc | 50 ++++ .../src/ft/ftturtlefiletransferitem.h | 49 ++-- libretroshare/src/serialiser/rstlvbase.cc | 4 +- libretroshare/src/serialiser/rstlvbase.h | 2 +- .../src/serialization/rstypeserializer.cc | 18 +- .../src/serialization/rstypeserializer.h | 59 ++++- libretroshare/src/turtle/p3turtle.cc | 20 +- libretroshare/src/turtle/rsturtleitem.cc | 247 +++++++++++++++--- libretroshare/src/turtle/rsturtleitem.h | 91 +++---- .../src/turtle/turtleclientservice.h | 4 +- 12 files changed, 419 insertions(+), 161 deletions(-) diff --git a/libretroshare/src/ft/ftserver.cc b/libretroshare/src/ft/ftserver.cc index caab409e8..b9c0c46c0 100644 --- a/libretroshare/src/ft/ftserver.cc +++ b/libretroshare/src/ft/ftserver.cc @@ -64,7 +64,7 @@ static const time_t FILE_TRANSFER_LOW_PRIORITY_TASKS_PERIOD = 5 ; // low priorit /* Setup */ ftServer::ftServer(p3PeerMgr *pm, p3ServiceControl *sc) - : p3Service(), + : p3Service(),RsSerializer(RS_SERVICE_TYPE_TURTLE), // should be FT, but this is for backward compatibility mPeerMgr(pm), mServiceCtrl(sc), mFileDatabase(NULL), mFtController(NULL), mFtExtra(NULL), @@ -459,14 +459,12 @@ bool ftServer::FileDetails(const RsFileHash &hash, FileSearchFlags hintflags, Fi return false; } -RsTurtleGenericTunnelItem *ftServer::deserialiseItem(void *data,uint32_t size) const +RsItem *ftServer::create_item(uint16_t service,uint8_t item_type) { - uint32_t rstype = getRsItemId(data); - #ifdef SERVER_DEBUG FTSERVER_DEBUG() << "p3turtle: deserialising packet: " << std::endl ; #endif - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_TURTLE != getRsItemService(rstype))) + if (RS_SERVICE_TYPE_TURTLE != service) { FTSERVER_ERROR() << " Wrong type !!" << std::endl ; return NULL; /* wrong type */ @@ -474,14 +472,14 @@ RsTurtleGenericTunnelItem *ftServer::deserialiseItem(void *data,uint32_t size) c try { - switch(getRsItemSubType(rstype)) + switch(item_type) { - case RS_TURTLE_SUBTYPE_FILE_REQUEST : return new RsTurtleFileRequestItem(data,size) ; - case RS_TURTLE_SUBTYPE_FILE_DATA : return new RsTurtleFileDataItem(data,size) ; - case RS_TURTLE_SUBTYPE_FILE_MAP_REQUEST : return new RsTurtleFileMapRequestItem(data,size) ; - case RS_TURTLE_SUBTYPE_FILE_MAP : return new RsTurtleFileMapItem(data,size) ; - case RS_TURTLE_SUBTYPE_CHUNK_CRC_REQUEST : return new RsTurtleChunkCrcRequestItem(data,size) ; - case RS_TURTLE_SUBTYPE_CHUNK_CRC : return new RsTurtleChunkCrcItem(data,size) ; + case RS_TURTLE_SUBTYPE_FILE_REQUEST : return new RsTurtleFileRequestItem(); + case RS_TURTLE_SUBTYPE_FILE_DATA : return new RsTurtleFileDataItem(); + case RS_TURTLE_SUBTYPE_FILE_MAP_REQUEST : return new RsTurtleFileMapRequestItem(); + case RS_TURTLE_SUBTYPE_FILE_MAP : return new RsTurtleFileMapItem(); + case RS_TURTLE_SUBTYPE_CHUNK_CRC_REQUEST : return new RsTurtleChunkCrcRequestItem(); + case RS_TURTLE_SUBTYPE_CHUNK_CRC : return new RsTurtleChunkCrcItem(); default: return NULL ; @@ -1189,7 +1187,8 @@ bool ftServer::encryptItem(RsTurtleGenericTunnelItem *clear_item,const RsFileHas FTSERVER_DEBUG() << " random nonce : " << RsUtil::BinToHex(initialization_vector,ENCRYPTED_FT_INITIALIZATION_VECTOR_SIZE) << std::endl; #endif - uint32_t total_data_size = ENCRYPTED_FT_HEADER_SIZE + ENCRYPTED_FT_INITIALIZATION_VECTOR_SIZE + ENCRYPTED_FT_EDATA_SIZE + clear_item->serial_size() + ENCRYPTED_FT_AUTHENTICATION_TAG_SIZE ; + uint32_t item_serialized_size = size(clear_item) ; + uint32_t total_data_size = ENCRYPTED_FT_HEADER_SIZE + ENCRYPTED_FT_INITIALIZATION_VECTOR_SIZE + ENCRYPTED_FT_EDATA_SIZE + item_serialized_size + ENCRYPTED_FT_AUTHENTICATION_TAG_SIZE ; #ifdef SERVER_DEBUG FTSERVER_DEBUG() << " clear part size : " << clear_item->serial_size() << std::endl; @@ -1204,7 +1203,7 @@ bool ftServer::encryptItem(RsTurtleGenericTunnelItem *clear_item,const RsFileHas return false ; uint8_t *edata = (uint8_t*)encrypted_item->data_bytes ; - uint32_t edata_size = clear_item->serial_size() ; + uint32_t edata_size = item_serialized_size; uint32_t offset = 0; edata[0] = 0xae ; @@ -1227,7 +1226,8 @@ bool ftServer::encryptItem(RsTurtleGenericTunnelItem *clear_item,const RsFileHas offset += ENCRYPTED_FT_EDATA_SIZE ; uint32_t ser_size = (uint32_t)((int)total_data_size - (int)offset); - clear_item->serialize(&edata[offset], ser_size); + + serialise(clear_item,&edata[offset], &ser_size); #ifdef SERVER_DEBUG FTSERVER_DEBUG() << " clear item : " << RsUtil::BinToHex(&edata[offset],std::min(50,(int)total_data_size-(int)offset)) << "(...)" << std::endl; @@ -1331,7 +1331,7 @@ bool ftServer::decryptItem(RsTurtleGenericDataItem *encrypted_item,const RsFileH return false ; } - decrypted_item = deserialiseItem(&edata[clear_item_offset],edata_size) ; + decrypted_item = dynamic_cast(deserialise(&edata[clear_item_offset],&edata_size)) ; if(decrypted_item == NULL) return false ; diff --git a/libretroshare/src/ft/ftserver.h b/libretroshare/src/ft/ftserver.h index d52c539d0..cda01eed6 100644 --- a/libretroshare/src/ft/ftserver.h +++ b/libretroshare/src/ft/ftserver.h @@ -68,7 +68,7 @@ class p3PeerMgr; class p3ServiceControl; class p3FileDatabase; -class ftServer: public p3Service, public RsFiles, public ftDataSend, public RsTurtleClientService +class ftServer: public p3Service, public RsFiles, public ftDataSend, public RsTurtleClientService, public RsSerializer { public: @@ -97,7 +97,7 @@ public: // virtual bool handleTunnelRequest(const RsFileHash& hash,const RsPeerId& peer_id) ; virtual void receiveTurtleData(RsTurtleGenericTunnelItem *item,const RsFileHash& hash,const RsPeerId& virtual_peer_id,RsTurtleGenericTunnelItem::Direction direction) ; - virtual RsTurtleGenericTunnelItem *deserialiseItem(void *data,uint32_t size) const ; + virtual RsItem *create_item(uint16_t service,uint8_t item_type) ; void addVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&,RsTurtleGenericTunnelItem::Direction dir) ; void removeVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&) ; diff --git a/libretroshare/src/ft/ftturtlefiletransferitem.cc b/libretroshare/src/ft/ftturtlefiletransferitem.cc index b4ce91623..e8f1bc886 100644 --- a/libretroshare/src/ft/ftturtlefiletransferitem.cc +++ b/libretroshare/src/ft/ftturtlefiletransferitem.cc @@ -30,6 +30,9 @@ #include #include +#include + +#ifdef TO_REMOVE uint32_t RsTurtleFileRequestItem::serial_size() const { uint32_t s = 0 ; @@ -101,6 +104,15 @@ uint32_t RsTurtleChunkCrcRequestItem::serial_size() const return s ; } +#endif + +void RsTurtleFileMapRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,direction,"direction") ; +} + +#ifdef TO_REMOVE bool RsTurtleFileMapRequestItem::serialize(void *data,uint32_t& pktsize) const { uint32_t tlvsize = serial_size(); @@ -134,6 +146,7 @@ bool RsTurtleFileMapRequestItem::serialize(void *data,uint32_t& pktsize) const return ok; } + bool RsTurtleFileMapItem::serialize(void *data,uint32_t& pktsize) const { uint32_t tlvsize = serial_size(); @@ -563,3 +576,40 @@ std::ostream& RsTurtleChunkCrcItem::print(std::ostream& o, uint16_t) return o ; } +#endif + +void RsTurtleFileMapItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,direction,"direction") ; + RsTypeSerializer::serial_process (j,ctx,compressed_map._map,"map") ; +} +void RsTurtleChunkCrcRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,chunk_number,"chunk_number") ; +} +void RsTurtleChunkCrcItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,chunk_number,"chunk_number") ; + RsTypeSerializer::serial_process (j,ctx,check_sum,"check_sum") ; +} + +void RsTurtleFileRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,chunk_offset,"chunk_offset") ; + RsTypeSerializer::serial_process(j,ctx,chunk_size,"chunk_size") ; +} +void RsTurtleFileDataItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,chunk_offset,"chunk_offset") ; + RsTypeSerializer::serial_process(j,ctx,chunk_size,"chunk_size") ; + + RsTypeSerializer::TlvMemBlock_proxy prox(chunk_data,chunk_size) ; + + RsTypeSerializer::serial_process(j,ctx,prox,"chunk_data") ; +} + diff --git a/libretroshare/src/ft/ftturtlefiletransferitem.h b/libretroshare/src/ft/ftturtlefiletransferitem.h index 8a886918e..fd8aada93 100644 --- a/libretroshare/src/ft/ftturtlefiletransferitem.h +++ b/libretroshare/src/ft/ftturtlefiletransferitem.h @@ -34,7 +34,6 @@ class RsTurtleFileRequestItem: public RsTurtleGenericTunnelItem { public: RsTurtleFileRequestItem() : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_FILE_REQUEST) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_FILE_REQUEST);} - RsTurtleFileRequestItem(void *data,uint32_t size) ; // deserialization virtual bool shouldStampTunnel() const { return false ; } virtual Direction travelingDirection() const { return DIRECTION_SERVER ; } @@ -42,51 +41,50 @@ class RsTurtleFileRequestItem: public RsTurtleGenericTunnelItem uint64_t chunk_offset ; uint32_t chunk_size ; - virtual std::ostream& print(std::ostream& o, uint16_t) ; + void clear() {} protected: - virtual bool serialize(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; + void serial_process(SerializeJob j,SerializeContext& ctx); }; class RsTurtleFileDataItem: public RsTurtleGenericTunnelItem { public: RsTurtleFileDataItem() : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_FILE_DATA) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_FILE_DATA) ;} - ~RsTurtleFileDataItem() ; - RsTurtleFileDataItem(void *data,uint32_t size) ; // deserialization + ~RsTurtleFileDataItem() { clear() ; } virtual bool shouldStampTunnel() const { return true ; } virtual Direction travelingDirection() const { return DIRECTION_CLIENT ; } + void clear() + { + free(chunk_data); + chunk_data = NULL ; + chunk_size = 0 ; + chunk_offset = 0 ; + } + uint64_t chunk_offset ; // offset in the file uint32_t chunk_size ; // size of the file chunk void *chunk_data ; // actual data. - virtual std::ostream& print(std::ostream& o, uint16_t) ; - - virtual bool serialize(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; + void serial_process(SerializeJob j,SerializeContext& ctx); }; class RsTurtleFileMapRequestItem: public RsTurtleGenericTunnelItem { public: RsTurtleFileMapRequestItem() : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_FILE_MAP_REQUEST) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_FILE_MAP_REQUEST) ;} - RsTurtleFileMapRequestItem(void *data,uint32_t size) ; // deserialization virtual bool shouldStampTunnel() const { return false ; } - virtual std::ostream& print(std::ostream& o, uint16_t) ; - - virtual bool serialize(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; + void clear() {} + void serial_process(SerializeJob j,SerializeContext& ctx); }; class RsTurtleFileMapItem: public RsTurtleGenericTunnelItem { public: RsTurtleFileMapItem() : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_FILE_MAP) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_FILE_MAP) ;} - RsTurtleFileMapItem(void *data,uint32_t size) ; // deserialization virtual bool shouldStampTunnel() const { return false ; } @@ -94,34 +92,28 @@ class RsTurtleFileMapItem: public RsTurtleGenericTunnelItem // by default, we suppose the peer has all the chunks. This info will thus be and-ed // with the default file map for this source. - virtual std::ostream& print(std::ostream& o, uint16_t) ; - - virtual bool serialize(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; + void clear() { compressed_map._map.clear() ;} + void serial_process(SerializeJob j,SerializeContext& ctx); }; class RsTurtleChunkCrcRequestItem: public RsTurtleGenericTunnelItem { public: RsTurtleChunkCrcRequestItem() : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_CHUNK_CRC_REQUEST) { setPriorityLevel(QOS_PRIORITY_RS_CHUNK_CRC_REQUEST);} - RsTurtleChunkCrcRequestItem(void *data,uint32_t size) ; // deserialization virtual bool shouldStampTunnel() const { return false ; } virtual Direction travelingDirection() const { return DIRECTION_SERVER ; } uint32_t chunk_number ; // id of the chunk to CRC. - virtual std::ostream& print(std::ostream& o, uint16_t) ; - - virtual bool serialize(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; + void clear() {} + void serial_process(SerializeJob j,SerializeContext& ctx); }; class RsTurtleChunkCrcItem: public RsTurtleGenericTunnelItem { public: RsTurtleChunkCrcItem() : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_CHUNK_CRC) { setPriorityLevel(QOS_PRIORITY_RS_CHUNK_CRC);} - RsTurtleChunkCrcItem(void *data,uint32_t size) ; // deserialization virtual bool shouldStampTunnel() const { return true ; } virtual Direction travelingDirection() const { return DIRECTION_CLIENT ; } @@ -129,7 +121,6 @@ class RsTurtleChunkCrcItem: public RsTurtleGenericTunnelItem uint32_t chunk_number ; Sha1CheckSum check_sum ; - virtual std::ostream& print(std::ostream& o, uint16_t) ; - virtual bool serialize(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; + void clear() { check_sum.clear() ;} + void serial_process(SerializeJob j,SerializeContext& ctx); }; diff --git a/libretroshare/src/serialiser/rstlvbase.cc b/libretroshare/src/serialiser/rstlvbase.cc index afc29a99e..f92dae4d9 100644 --- a/libretroshare/src/serialiser/rstlvbase.cc +++ b/libretroshare/src/serialiser/rstlvbase.cc @@ -32,7 +32,7 @@ //********************* // A facility func -inline void* right_shift_void_pointer(void* p, uint32_t len) { +inline void* right_shift_void_pointer(const void* p, uint32_t len) { return (void*)( (uint8_t*)p + len); } @@ -550,7 +550,7 @@ static bool find_decoded_string(const std::string& in,const std::string& suspici } //tested -bool GetTlvString(void *data, uint32_t size, uint32_t *offset, +bool GetTlvString(const void *data, uint32_t size, uint32_t *offset, uint16_t type, std::string &in) { if (!data) diff --git a/libretroshare/src/serialiser/rstlvbase.h b/libretroshare/src/serialiser/rstlvbase.h index f33a7d8ee..3f6ac1102 100644 --- a/libretroshare/src/serialiser/rstlvbase.h +++ b/libretroshare/src/serialiser/rstlvbase.h @@ -275,7 +275,7 @@ uint32_t GetTlvUInt64Size(); bool SetTlvString(void *data, uint32_t size, uint32_t *offset, uint16_t type, std::string out); -bool GetTlvString(void *data, uint32_t size, uint32_t *offset, uint16_t type, std::string &in); +bool GetTlvString(const void *data, uint32_t size, uint32_t *offset, uint16_t type, std::string &in); uint32_t GetTlvStringSize(const std::string &in); #ifdef REMOVED_CODE diff --git a/libretroshare/src/serialization/rstypeserializer.cc b/libretroshare/src/serialization/rstypeserializer.cc index 5a8def1bd..2c68d2c0c 100644 --- a/libretroshare/src/serialization/rstypeserializer.cc +++ b/libretroshare/src/serialization/rstypeserializer.cc @@ -22,7 +22,11 @@ template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint3 { return setRawUInt8(data,size,&offset,member); } -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint32_t& member) +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint16_t& member) +{ + return setRawUInt16(data,size,&offset,member); +} +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const uint32_t& member) { return setRawUInt32(data,size,&offset,member); } @@ -46,7 +50,11 @@ template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t siz { return getRawUInt8(data,size,&offset,&member); } -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint32_t& member) +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint16_t& member) +{ + return getRawUInt16(data,size,&offset,&member); +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, uint32_t& member) { return getRawUInt32(data,size,&offset,&member); } @@ -67,6 +75,10 @@ template<> uint32_t RsTypeSerializer::serial_size(const uint8_t& /* member*/) { return 1; } +template<> uint32_t RsTypeSerializer::serial_size(const uint16_t& /* member*/) +{ + return 2; +} template<> uint32_t RsTypeSerializer::serial_size(const uint32_t& /* member*/) { return 4; @@ -224,7 +236,7 @@ template<> bool RsTypeSerializer::serialize(uint8_t data[],uint32_t size,uint32_ template<> void RsTypeSerializer::print_data(const std::string& n, const RsTypeSerializer::TlvMemBlock_proxy& s) { - std::cerr << " [Binary data] " << n << ", length=" << s.second << " data=" << RsUtil::BinToHex(s.first,std::min(50u,s.second)) << ((s.second>50)?"...":"") << std::endl; + std::cerr << " [Binary data] " << n << ", length=" << s.second << " data=" << RsUtil::BinToHex((uint8_t*)s.first,std::min(50u,s.second)) << ((s.second>50)?"...":"") << std::endl; } //=================================================================================================// diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 349689c0b..403219ecb 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -26,7 +26,11 @@ class RsTypeSerializer public: // This type should be used to pass a parameter to drive the serialisation if needed. - typedef std::pair TlvMemBlock_proxy; + struct TlvMemBlock_proxy: public std::pair + { + TlvMemBlock_proxy(void *& p,uint32_t& s) : std::pair(p,s) {} + TlvMemBlock_proxy(uint8_t*& p,uint32_t& s) : std::pair(*(void**)&p,s) {} + }; //=================================================================================================// // Generic types // @@ -135,6 +139,59 @@ class RsTypeSerializer break; } } + + //=================================================================================================// + // std::list // + //=================================================================================================// + + template + static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,std::list& v,const std::string& member_name) + { + switch(j) + { + case RsItem::SIZE_ESTIMATE: + { + ctx.mOffset += 4 ; + for(typename std::list::iterator it(v.begin());it!=v.end();++it) + serial_process(j,ctx,*it ,member_name) ; + } + break ; + + case RsItem::DESERIALIZE: + { uint32_t n=0 ; + serial_process(j,ctx,n,"temporary size") ; + + for(uint32_t i=0;i(j,ctx,tmp,member_name) ; + v.push_back(tmp); + } + } + break ; + + case RsItem::SERIALIZE: + { + uint32_t n=v.size(); + serial_process(j,ctx,n,"temporary size") ; + for(typename std::list::iterator it(v.begin());it!=v.end();++it) + serial_process(j,ctx,*it ,member_name) ; + } + break ; + + case RsItem::PRINT: + { + if(v.empty()) + std::cerr << " Empty list"<< std::endl; + else + std::cerr << " List of " << v.size() << " elements:" << std::endl; + } + break; + default: + break; + } + } + //=================================================================================================// // t_RsFlags32<> types // //=================================================================================================// diff --git a/libretroshare/src/turtle/p3turtle.cc b/libretroshare/src/turtle/p3turtle.cc index 997fe0e7e..1cfbc2cbd 100644 --- a/libretroshare/src/turtle/p3turtle.cc +++ b/libretroshare/src/turtle/p3turtle.cc @@ -852,12 +852,14 @@ void p3turtle::handleSearchRequest(RsTurtleSearchRequestItem *item) item->print(std::cerr,0) ; #endif - if(item->serial_size() > TURTLE_MAX_SEARCH_REQ_ACCEPTED_SERIAL_SIZE) + uint32_t item_size = RsTurtleSerialiser().size(item); + + if(item_size > TURTLE_MAX_SEARCH_REQ_ACCEPTED_SERIAL_SIZE) { #ifdef P3TURTLE_DEBUG std::cerr << " Dropping, because the serial size exceeds the accepted limit." << std::endl ; #endif - std::cerr << " Caught a turtle search item with arbitrary large size from " << item->PeerId() << " of size " << item->serial_size() << " and depth " << item->depth << ". This is not allowed => dropping." << std::endl; + std::cerr << " Caught a turtle search item with arbitrary large size from " << item->PeerId() << " of size " << item_size << " and depth " << item->depth << ". This is not allowed => dropping." << std::endl; return ; } @@ -1074,7 +1076,7 @@ void p3turtle::routeGenericTunnelItem(RsTurtleGenericTunnelItem *item) if(item->shouldStampTunnel()) tunnel.time_stamp = time(NULL) ; - tunnel.transfered_bytes += static_cast(item)->serial_size() ; + tunnel.transfered_bytes += RsTurtleSerialiser().size(item); if(item->PeerId() == tunnel.local_dst) item->setTravelingDirection(RsTurtleGenericTunnelItem::DIRECTION_CLIENT) ; @@ -1100,7 +1102,7 @@ void p3turtle::routeGenericTunnelItem(RsTurtleGenericTunnelItem *item) #endif item->PeerId(tunnel.local_src) ; - _traffic_info_buffer.unknown_updn_Bps += static_cast(item)->serial_size() ; + _traffic_info_buffer.unknown_updn_Bps += RsTurtleSerialiser().size(item) ; // This has been disabled for compilation reasons. Not sure we actually need it. // @@ -1118,7 +1120,7 @@ void p3turtle::routeGenericTunnelItem(RsTurtleGenericTunnelItem *item) #endif item->PeerId(tunnel.local_dst) ; - _traffic_info_buffer.unknown_updn_Bps += static_cast(item)->serial_size() ; + _traffic_info_buffer.unknown_updn_Bps += RsTurtleSerialiser().size(item); sendItem(item) ; return ; @@ -1126,7 +1128,7 @@ void p3turtle::routeGenericTunnelItem(RsTurtleGenericTunnelItem *item) // item is for us. Use the locked region to record the data. - _traffic_info_buffer.data_dn_Bps += item->serial_size() ; + _traffic_info_buffer.data_dn_Bps += RsTurtleSerialiser().size(item); } // The packet was not forwarded, so it is for us. Let's treat it. @@ -1246,7 +1248,7 @@ void p3turtle::sendTurtleData(const RsPeerId& virtual_peer_id,RsTurtleGenericTun item->tunnel_id = tunnel_id ; // we should randomly select a tunnel, or something more clever. - uint32_t ss = item->serial_size() ; + uint32_t ss = RsTurtleSerialiser().size(item); if(item->shouldStampTunnel()) tunnel.time_stamp = time(NULL) ; @@ -1380,7 +1382,7 @@ void p3turtle::handleTunnelRequest(RsTurtleOpenTunnelItem *item) { RsStackMutex stack(mTurtleMtx); /********** STACK LOCKED MTX ******/ - _traffic_info_buffer.tr_dn_Bps += static_cast(item)->serial_size() ; + _traffic_info_buffer.tr_dn_Bps += RsTurtleSerialiser().size(item); float distance_to_maximum = std::min(100.0f,_traffic_info.tr_up_Bps/(float)(TUNNEL_REQUEST_PACKET_SIZE*_max_tr_up_rate)) ; float corrected_distance = pow(distance_to_maximum,DISTANCE_SQUEEZING_POWER) ; @@ -1572,7 +1574,7 @@ void p3turtle::handleTunnelRequest(RsTurtleOpenTunnelItem *item) { RsStackMutex stack(mTurtleMtx); /********** STACK LOCKED MTX ******/ - _traffic_info_buffer.tr_up_Bps += static_cast(fwd_item)->serial_size() ; + _traffic_info_buffer.tr_up_Bps += RsTurtleSerialiser().size(fwd_item); } sendItem(fwd_item) ; diff --git a/libretroshare/src/turtle/rsturtleitem.cc b/libretroshare/src/turtle/rsturtleitem.cc index c1965deee..577d152a8 100644 --- a/libretroshare/src/turtle/rsturtleitem.cc +++ b/libretroshare/src/turtle/rsturtleitem.cc @@ -6,6 +6,8 @@ #include "rsturtleitem.h" #include "turtleclientservice.h" +#include "serialization/rstypeserializer.h" + //#define P3TURTLE_DEBUG // -----------------------------------------------------------------------------------// // -------------------------------- Serialization. --------------------------------- // @@ -16,6 +18,7 @@ // ---------------------------------- Packet sizes -----------------------------------// // +#ifdef TO_REMOVE uint32_t RsTurtleStringSearchRequestItem::serial_size() const { uint32_t s = 0 ; @@ -102,19 +105,13 @@ uint32_t RsTurtleGenericDataItem::serial_size() const return s ; } +#endif // // ---------------------------------- Serialization ----------------------------------// // -RsItem *RsTurtleSerialiser::deserialise(void *data, uint32_t *size) +RsItem *RsTurtleSerialiser::create_item(uint16_t service,uint8_t item_subtype) { - // look what we have... - - /* get the type */ - uint32_t rstype = getRsItemId(data); -#ifdef P3TURTLE_DEBUG - std::cerr << "p3turtle: deserialising packet: " << std::endl ; -#endif - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_TURTLE != getRsItemService(rstype))) + if (RS_SERVICE_TYPE_TURTLE != service) { #ifdef P3TURTLE_DEBUG std::cerr << " Wrong type !!" << std::endl ; @@ -122,43 +119,38 @@ RsItem *RsTurtleSerialiser::deserialise(void *data, uint32_t *size) return NULL; /* wrong type */ } -#ifndef WINDOWS_SYS - try + switch(getRsItemSubType(item_subtype)) { -#endif - switch(getRsItemSubType(rstype)) - { - case RS_TURTLE_SUBTYPE_STRING_SEARCH_REQUEST : return new RsTurtleStringSearchRequestItem(data,*size) ; - case RS_TURTLE_SUBTYPE_REGEXP_SEARCH_REQUEST : return new RsTurtleRegExpSearchRequestItem(data,*size) ; - case RS_TURTLE_SUBTYPE_SEARCH_RESULT : return new RsTurtleSearchResultItem(data,*size) ; - case RS_TURTLE_SUBTYPE_OPEN_TUNNEL : return new RsTurtleOpenTunnelItem(data,*size) ; - case RS_TURTLE_SUBTYPE_TUNNEL_OK : return new RsTurtleTunnelOkItem(data,*size) ; - case RS_TURTLE_SUBTYPE_GENERIC_DATA : return new RsTurtleGenericDataItem(data,*size) ; - - default: - break ; - } - // now try all client services - // - RsItem *item = NULL ; + case RS_TURTLE_SUBTYPE_STRING_SEARCH_REQUEST : return new RsTurtleStringSearchRequestItem(); + case RS_TURTLE_SUBTYPE_REGEXP_SEARCH_REQUEST : return new RsTurtleRegExpSearchRequestItem(); + case RS_TURTLE_SUBTYPE_SEARCH_RESULT : return new RsTurtleSearchResultItem(); + case RS_TURTLE_SUBTYPE_OPEN_TUNNEL : return new RsTurtleOpenTunnelItem(); + case RS_TURTLE_SUBTYPE_TUNNEL_OK : return new RsTurtleTunnelOkItem(); + case RS_TURTLE_SUBTYPE_GENERIC_DATA : return new RsTurtleGenericDataItem(); - for(uint32_t i=0;i<_client_services.size();++i) - if((item = _client_services[i]->deserialiseItem(data,*size)) != NULL) - return item ; - - std::cerr << "Unknown packet type in RsTurtle (not even handled by client services)!" << std::endl ; - return NULL ; -#ifndef WINDOWS_SYS + default: + break ; } - catch(std::exception& e) - { - std::cerr << "Exception raised: " << e.what() << std::endl ; - return NULL ; - } -#endif + // now try all client services + // + RsItem *item = NULL ; + for(uint32_t i=0;i<_client_services.size();++i) + if((item = _client_services[i]->create_item(service,item_subtype)) != NULL) + return item ; + + std::cerr << "Unknown packet type in RsTurtle (not even handled by client services)!" << std::endl ; + return NULL ; } +void RsTurtleStringSearchRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_VALUE,match_string,"match_string") ; + RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; + RsTypeSerializer::serial_process(j,ctx,depth ,"depth") ; +} + +#ifdef TO_REMOVE bool RsTurtleStringSearchRequestItem::serialize(void *data,uint32_t& pktsize) const { uint32_t tlvsize = serial_size(); @@ -242,7 +234,95 @@ bool RsTurtleRegExpSearchRequestItem::serialize(void *data,uint32_t& pktsize) co return ok; } +#endif +void RsTurtleRegExpSearchRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; + RsTypeSerializer::serial_process(j,ctx,depth,"depth") ; + RsTypeSerializer::serial_process(j,ctx,expr,"expr") ; +} + +template<> uint32_t RsTypeSerializer::serial_size(const RsRegularExpression::LinearizedExpression& r) +{ + uint32_t s = 0 ; + + s += 4 ; // number of strings + + for(unsigned int i=0;i bool RsTypeSerializer::deserialize(const uint8_t data[],uint32_t size,uint32_t& offset,RsRegularExpression::LinearizedExpression& expr) +{ + uint32_t saved_offset = offset ; + + uint32_t n =0 ; + bool ok = true ; + + ok &= getRawUInt32(data,size,&offset,&n) ; + + if(ok) expr._tokens.resize(n) ; + + for(uint32_t i=0;i bool RsTypeSerializer::serialize(uint8_t data[],uint32_t size,uint32_t& offset,const RsRegularExpression::LinearizedExpression& expr) +{ + uint32_t saved_offset = offset ; + + bool ok = true ; + + ok &= setRawUInt32(data,size,&offset,expr._tokens.size()) ; + + for(unsigned int i=0;i void RsTypeSerializer::print_data(const std::string& n, const RsRegularExpression::LinearizedExpression& expr) +{ + std::cerr << " [RegExpr ] " << n << ", tokens=" << expr._tokens.size() << " ints=" << expr._ints.size() << " strings=" << expr._strings.size() << std::endl; +} + + +#ifdef TO_REMOVE RsTurtleStringSearchRequestItem::RsTurtleStringSearchRequestItem(void *data,uint32_t pktsize) : RsTurtleSearchRequestItem(RS_TURTLE_SUBTYPE_STRING_SEARCH_REQUEST) { @@ -309,6 +389,62 @@ RsTurtleRegExpSearchRequestItem::RsTurtleRegExpSearchRequestItem(void *data,uint throw std::runtime_error("Unknown error while deserializing.") ; #endif } +#endif + +void RsTurtleSearchResultItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; + RsTypeSerializer::serial_process(j,ctx,depth ,"depth") ; + RsTypeSerializer::serial_process (j,ctx,result ,"result") ; +} + +template<> uint32_t RsTypeSerializer::serial_size(const TurtleFileInfo& i) +{ + uint32_t s = 0 ; + + s += 8 ; // size + s += i.hash.SIZE_IN_BYTES ; + s += GetTlvStringSize(i.name) ; + + return s; +} + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[],uint32_t size,uint32_t& offset,TurtleFileInfo& i) +{ + uint32_t saved_offset = offset ; + bool ok = true ; + + ok &= getRawUInt64(data, size, &offset, &i.size); // file size + ok &= i.hash.deserialise(data, size, offset); // file hash + ok &= GetTlvString(data, size, &offset, TLV_TYPE_STR_NAME, i.name); // file name + + if(!ok) + offset = saved_offset ; + + return ok; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[],uint32_t size,uint32_t& offset,const TurtleFileInfo& i) +{ + uint32_t saved_offset = offset ; + bool ok = true ; + + ok &= setRawUInt64(data, size, &offset, i.size); // file size + ok &= i.hash.serialise(data, size, offset); // file hash + ok &= SetTlvString(data, size, &offset, TLV_TYPE_STR_NAME, i.name); // file name + + if(!ok) + offset = saved_offset ; + + return ok; +} + +template<> void RsTypeSerializer::print_data(const std::string& n, const TurtleFileInfo& i) +{ + std::cerr << " [FileInfo ] " << n << " size=" << i.size << " hash=" << i.hash << ", name=" << i.name << std::endl; +} + +#ifdef TO_REMOVE bool RsTurtleSearchResultItem::serialize(void *data,uint32_t& pktsize) const { @@ -394,7 +530,17 @@ RsTurtleSearchResultItem::RsTurtleSearchResultItem(void *data,uint32_t pktsize) throw std::runtime_error("Unknown error while deserializing.") ; #endif } +#endif +void RsTurtleOpenTunnelItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,file_hash ,"file_hash") ; + RsTypeSerializer::serial_process(j,ctx,request_id ,"request_id") ; + RsTypeSerializer::serial_process(j,ctx,partial_tunnel_id,"partial_tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,depth ,"depth") ; +} + +#ifdef TO_REMOVE bool RsTurtleOpenTunnelItem::serialize(void *data,uint32_t& pktsize) const { uint32_t tlvsize = serial_size(); @@ -460,7 +606,15 @@ RsTurtleOpenTunnelItem::RsTurtleOpenTunnelItem(void *data,uint32_t pktsize) throw std::runtime_error("RsTurtleOpenTunnelItem::() unknown error while deserializing.") ; #endif } +#endif +void RsTurtleTunnelOkItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id ,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; +} + +#ifdef TO_REMOVE bool RsTurtleTunnelOkItem::serialize(void *data,uint32_t& pktsize) const { uint32_t tlvsize = serial_size(); @@ -522,7 +676,18 @@ RsTurtleTunnelOkItem::RsTurtleTunnelOkItem(void *data,uint32_t pktsize) throw std::runtime_error("RsTurtleTunnelOkItem::() unknown error while deserializing.") ; #endif } +#endif +void RsTurtleGenericDataItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id ,"tunnel_id") ; + + RsTypeSerializer::TlvMemBlock_proxy prox(data_bytes,data_size) ; + + RsTypeSerializer::serial_process(j,ctx,prox,"data bytes") ; +} + +#ifdef TO_REMOVE RsTurtleGenericDataItem::RsTurtleGenericDataItem(void *data,uint32_t pktsize) : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_GENERIC_DATA) { @@ -604,6 +769,7 @@ bool RsTurtleGenericDataItem::serialize(void *data,uint32_t& pktsize) const return ok; } + // -----------------------------------------------------------------------------------// // ------------------------------------- IO --------------------------------------- // // -----------------------------------------------------------------------------------// @@ -681,3 +847,4 @@ std::ostream& RsTurtleGenericDataItem::print(std::ostream& o, uint16_t) return o ; } +#endif diff --git a/libretroshare/src/turtle/rsturtleitem.h b/libretroshare/src/turtle/rsturtleitem.h index 5b15f7781..22477668a 100644 --- a/libretroshare/src/turtle/rsturtleitem.h +++ b/libretroshare/src/turtle/rsturtleitem.h @@ -9,6 +9,8 @@ #include "serialiser/rsserviceids.h" #include "turtle/turtletypes.h" +#include "serialization/rsserializer.h" + const uint8_t RS_TURTLE_SUBTYPE_STRING_SEARCH_REQUEST = 0x01 ; const uint8_t RS_TURTLE_SUBTYPE_SEARCH_RESULT = 0x02 ; const uint8_t RS_TURTLE_SUBTYPE_OPEN_TUNNEL = 0x03 ; @@ -17,14 +19,14 @@ const uint8_t RS_TURTLE_SUBTYPE_CLOSE_TUNNEL = 0x05 ; const uint8_t RS_TURTLE_SUBTYPE_TUNNEL_CLOSED = 0x06 ; const uint8_t RS_TURTLE_SUBTYPE_FILE_REQUEST = 0x07 ; const uint8_t RS_TURTLE_SUBTYPE_FILE_DATA = 0x08 ; -const uint8_t RS_TURTLE_SUBTYPE_REGEXP_SEARCH_REQUEST = 0x09 ; +const uint8_t RS_TURTLE_SUBTYPE_REGEXP_SEARCH_REQUEST = 0x09 ; const uint8_t RS_TURTLE_SUBTYPE_GENERIC_DATA = 0x0a ; -const uint8_t RS_TURTLE_SUBTYPE_FILE_MAP = 0x10 ; -const uint8_t RS_TURTLE_SUBTYPE_FILE_MAP_REQUEST = 0x11 ; -const uint8_t RS_TURTLE_SUBTYPE_FILE_CRC = 0x12 ; -const uint8_t RS_TURTLE_SUBTYPE_FILE_CRC_REQUEST = 0x13 ; -const uint8_t RS_TURTLE_SUBTYPE_CHUNK_CRC = 0x14 ; -const uint8_t RS_TURTLE_SUBTYPE_CHUNK_CRC_REQUEST = 0x15 ; +const uint8_t RS_TURTLE_SUBTYPE_FILE_MAP = 0x10 ; +const uint8_t RS_TURTLE_SUBTYPE_FILE_MAP_REQUEST = 0x11 ; +const uint8_t RS_TURTLE_SUBTYPE_FILE_CRC = 0x12 ; +const uint8_t RS_TURTLE_SUBTYPE_FILE_CRC_REQUEST = 0x13 ; +const uint8_t RS_TURTLE_SUBTYPE_CHUNK_CRC = 0x14 ; +const uint8_t RS_TURTLE_SUBTYPE_CHUNK_CRC_REQUEST = 0x15 ; /***********************************************************************************/ /* Basic Turtle Item Class */ @@ -34,11 +36,6 @@ class RsTurtleItem: public RsItem { public: RsTurtleItem(uint8_t turtle_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TURTLE,turtle_subtype) {} - - virtual bool serialize(void *data,uint32_t& size) const = 0 ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() const = 0 ; // deserialise is handled using a constructor - - virtual void clear() {} }; /***********************************************************************************/ @@ -50,29 +47,26 @@ class RsTurtleSearchResultItem: public RsTurtleItem { public: RsTurtleSearchResultItem() : RsTurtleItem(RS_TURTLE_SUBTYPE_SEARCH_RESULT), request_id(0), depth(0) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_SEARCH_RESULT) ;} - RsTurtleSearchResultItem(void *data,uint32_t size) ; // deserialization TurtleSearchRequestId request_id ; // Randomly generated request id. - uint16_t depth ; // The depth of a search result is obfuscated in this way: - // If the actual depth is 1, this field will be 1. - // If the actual depth is > 1, this field is a larger arbitrary integer. - + uint16_t depth ; // The depth of a search result is obfuscated in this way: + // If the actual depth is 1, this field will be 1. + // If the actual depth is > 1, this field is a larger arbitrary integer. std::list result ; - virtual std::ostream& print(std::ostream& o, uint16_t) ; - + void clear() { result.clear() ; } protected: - virtual bool serialize(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + void serial_process(SerializeJob j,SerializeContext& ctx); + }; class RsTurtleSearchRequestItem: public RsTurtleItem { public: RsTurtleSearchRequestItem(uint32_t subtype) : RsTurtleItem(subtype), request_id(0), depth(0) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_SEARCH_REQUEST) ;} + virtual RsTurtleSearchRequestItem *clone() const = 0 ; // used for cloning in routing methods - virtual RsTurtleSearchRequestItem *clone() const = 0 ; // used for cloning in routing methods virtual void performLocalSearch(std::list&) const = 0 ; // abstracts the search method uint32_t request_id ; // randomly generated request id. @@ -83,34 +77,31 @@ class RsTurtleStringSearchRequestItem: public RsTurtleSearchRequestItem { public: RsTurtleStringSearchRequestItem() : RsTurtleSearchRequestItem(RS_TURTLE_SUBTYPE_STRING_SEARCH_REQUEST) {} - RsTurtleStringSearchRequestItem(void *data,uint32_t size) ; std::string match_string ; // string to match virtual RsTurtleSearchRequestItem *clone() const { return new RsTurtleStringSearchRequestItem(*this) ; } virtual void performLocalSearch(std::list&) const ; - virtual std::ostream& print(std::ostream& o, uint16_t) ; + void clear() { match_string.clear() ; } + protected: - virtual bool serialize(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + void serial_process(SerializeJob j,SerializeContext& ctx); }; class RsTurtleRegExpSearchRequestItem: public RsTurtleSearchRequestItem { public: RsTurtleRegExpSearchRequestItem() : RsTurtleSearchRequestItem(RS_TURTLE_SUBTYPE_REGEXP_SEARCH_REQUEST) {} - RsTurtleRegExpSearchRequestItem(void *data,uint32_t size) ; RsRegularExpression::LinearizedExpression expr ; // Reg Exp in linearised mode virtual RsTurtleSearchRequestItem *clone() const { return new RsTurtleRegExpSearchRequestItem(*this) ; } virtual void performLocalSearch(std::list&) const ; - virtual std::ostream& print(std::ostream& o, uint16_t) ; + void clear() { expr = RsRegularExpression::LinearizedExpression(); } protected: - virtual bool serialize(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + void serial_process(SerializeJob j,SerializeContext& ctx); }; /***********************************************************************************/ @@ -121,34 +112,28 @@ class RsTurtleOpenTunnelItem: public RsTurtleItem { public: RsTurtleOpenTunnelItem() : RsTurtleItem(RS_TURTLE_SUBTYPE_OPEN_TUNNEL), request_id(0), partial_tunnel_id(0), depth(0) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_OPEN_TUNNEL) ;} - RsTurtleOpenTunnelItem(void *data,uint32_t size) ; // deserialization TurtleFileHash file_hash ; // hash to match uint32_t request_id ; // randomly generated request id. uint32_t partial_tunnel_id ; // uncomplete tunnel id. Will be completed at destination. uint16_t depth ; // Used for limiting search depth. - virtual std::ostream& print(std::ostream& o, uint16_t) ; - + void clear() { file_hash.clear() ;} protected: - virtual bool serialize(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + void serial_process(SerializeJob j,SerializeContext& ctx); }; class RsTurtleTunnelOkItem: public RsTurtleItem { public: RsTurtleTunnelOkItem() : RsTurtleItem(RS_TURTLE_SUBTYPE_TUNNEL_OK), tunnel_id(0), request_id(0) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_TUNNEL_OK) ;} - RsTurtleTunnelOkItem(void *data,uint32_t size) ; // deserialization uint32_t tunnel_id ; // id of the tunnel. Should be identical for a tunnel between two same peers for the same hash. uint32_t request_id ; // randomly generated request id corresponding to the intial request. - virtual std::ostream& print(std::ostream& o, uint16_t) ; - + void clear() {} protected: - virtual bool serialize(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + void serial_process(SerializeJob j,SerializeContext& ctx); }; /***********************************************************************************/ @@ -198,8 +183,6 @@ class RsTurtleGenericDataItem: public RsTurtleGenericTunnelItem { public: RsTurtleGenericDataItem() : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_GENERIC_DATA), data_size(0), data_bytes(0) { setPriorityLevel(QOS_PRIORITY_RS_TURTLE_FILE_REQUEST);} - RsTurtleGenericDataItem(void *data,uint32_t size) ; // deserialization - virtual ~RsTurtleGenericDataItem() { if(data_bytes != NULL) free(data_bytes) ; } virtual bool shouldStampTunnel() const { return true ; } @@ -207,30 +190,26 @@ class RsTurtleGenericDataItem: public RsTurtleGenericTunnelItem uint32_t data_size ; void *data_bytes ; - virtual std::ostream& print(std::ostream& o, uint16_t) ; + void clear() + { + free(data_bytes) ; + data_bytes = NULL ; + data_size = 0; + } protected: - virtual bool serialize(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + void serial_process(SerializeJob j,SerializeContext& ctx); }; /***********************************************************************************/ /* Turtle Serialiser class */ /***********************************************************************************/ -class RsTurtleSerialiser: public RsSerialType +class RsTurtleSerialiser: public RsSerializer { public: - RsTurtleSerialiser() : RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_TURTLE) {} + RsTurtleSerialiser() : RsSerializer(RS_SERVICE_TYPE_TURTLE) {} - virtual uint32_t size (RsItem *item) - { - return dynamic_cast(item)->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - return dynamic_cast(item)->serialize(data,*size) ; - } - virtual RsItem *deserialise (void *data, uint32_t *size) ; + virtual RsItem *create_item(uint16_t service,uint8_t item_subtype); // This is used by the turtle router to add services to its serialiser. // Client services are only used for deserialising, since the serialisation is diff --git a/libretroshare/src/turtle/turtleclientservice.h b/libretroshare/src/turtle/turtleclientservice.h index 033d5e046..6fa4dd629 100644 --- a/libretroshare/src/turtle/turtleclientservice.h +++ b/libretroshare/src/turtle/turtleclientservice.h @@ -71,12 +71,12 @@ class RsTurtleClientService std::cerr << "!!!!!! Received Data from turtle router, but the client service is not handling it !!!!!!!!!!" << std::endl ; } - // Method for deserialising specific items of the client service. The + // Method for creating specific items of the client service. The // method has a default behavior of not doing anything, since most client // services might only use the generic item already provided by the turtle // router: RsTurtleGenericDataItem - virtual RsTurtleGenericTunnelItem *deserialiseItem(void */*data*/, uint32_t /*size*/) const { return NULL ; } + virtual RsTurtleGenericTunnelItem *create_item(uint16_t service,uint8_t item_type) const { return NULL ; } // These methods are called by the turtle router to add/remove virtual peers when tunnels are created/deleted // From 121133488c7893601255bf9507a0953e0c5639a7 Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 16 Apr 2017 19:59:22 +0200 Subject: [PATCH 24/94] fixed bug in serialization for turtle --- libretroshare/src/chat/rschatitems.cc | 2 +- libretroshare/src/chat/rschatitems.h | 2 +- libretroshare/src/ft/ftserver.cc | 2 +- libretroshare/src/ft/ftserver.h | 3 ++- libretroshare/src/ft/ftturtlefiletransferitem.cc | 1 - libretroshare/src/serialiser/rsbanlistitems.cc | 2 +- libretroshare/src/serialiser/rsbanlistitems.h | 2 +- libretroshare/src/serialiser/rsbwctrlitems.cc | 2 +- libretroshare/src/serialiser/rsbwctrlitems.h | 2 +- libretroshare/src/serialiser/rsfiletransferitems.cc | 2 +- libretroshare/src/serialiser/rsfiletransferitems.h | 2 +- libretroshare/src/serialization/rsserializer.h | 2 +- libretroshare/src/turtle/rsturtleitem.cc | 4 ++-- libretroshare/src/turtle/rsturtleitem.h | 7 ++++--- libretroshare/src/turtle/turtleclientservice.h | 2 +- 15 files changed, 19 insertions(+), 18 deletions(-) diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 88e7abe8a..23f4aab25 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -37,7 +37,7 @@ static const uint32_t RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE = 0x0001; -RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) +RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) const { if(service_id != RS_SERVICE_TYPE_CHAT) return NULL ; diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 7ec79ea44..7771a375f 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -332,6 +332,6 @@ class RsChatSerialiser: public RsSerializer public: RsChatSerialiser() :RsSerializer(RS_SERVICE_TYPE_CHAT) {} - virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) ; + virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) const ; }; diff --git a/libretroshare/src/ft/ftserver.cc b/libretroshare/src/ft/ftserver.cc index b9c0c46c0..5b04f2828 100644 --- a/libretroshare/src/ft/ftserver.cc +++ b/libretroshare/src/ft/ftserver.cc @@ -459,7 +459,7 @@ bool ftServer::FileDetails(const RsFileHash &hash, FileSearchFlags hintflags, Fi return false; } -RsItem *ftServer::create_item(uint16_t service,uint8_t item_type) +RsItem *ftServer::create_item(uint16_t service,uint8_t item_type) const { #ifdef SERVER_DEBUG FTSERVER_DEBUG() << "p3turtle: deserialising packet: " << std::endl ; diff --git a/libretroshare/src/ft/ftserver.h b/libretroshare/src/ft/ftserver.h index cda01eed6..23606b28e 100644 --- a/libretroshare/src/ft/ftserver.h +++ b/libretroshare/src/ft/ftserver.h @@ -97,7 +97,8 @@ public: // virtual bool handleTunnelRequest(const RsFileHash& hash,const RsPeerId& peer_id) ; virtual void receiveTurtleData(RsTurtleGenericTunnelItem *item,const RsFileHash& hash,const RsPeerId& virtual_peer_id,RsTurtleGenericTunnelItem::Direction direction) ; - virtual RsItem *create_item(uint16_t service,uint8_t item_type) ; + virtual RsItem *create_item(uint16_t service,uint8_t item_type) const ; + virtual RsSerializer *serializer() { return this ; } void addVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&,RsTurtleGenericTunnelItem::Direction dir) ; void removeVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&) ; diff --git a/libretroshare/src/ft/ftturtlefiletransferitem.cc b/libretroshare/src/ft/ftturtlefiletransferitem.cc index e8f1bc886..722991aef 100644 --- a/libretroshare/src/ft/ftturtlefiletransferitem.cc +++ b/libretroshare/src/ft/ftturtlefiletransferitem.cc @@ -606,7 +606,6 @@ void RsTurtleFileDataItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,chunk_offset,"chunk_offset") ; - RsTypeSerializer::serial_process(j,ctx,chunk_size,"chunk_size") ; RsTypeSerializer::TlvMemBlock_proxy prox(chunk_data,chunk_size) ; diff --git a/libretroshare/src/serialiser/rsbanlistitems.cc b/libretroshare/src/serialiser/rsbanlistitems.cc index a110ec00f..c28399e34 100644 --- a/libretroshare/src/serialiser/rsbanlistitems.cc +++ b/libretroshare/src/serialiser/rsbanlistitems.cc @@ -53,7 +53,7 @@ void RsBanListConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext RsTypeSerializer::serial_process (j,ctx,update_time,"update_time") ; RsTypeSerializer::serial_process (j,ctx,banned_peers,"banned_peers") ; } -RsItem *RsBanListSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) +RsItem *RsBanListSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) const { if(service_id != RS_SERVICE_TYPE_BANLIST) return NULL ; diff --git a/libretroshare/src/serialiser/rsbanlistitems.h b/libretroshare/src/serialiser/rsbanlistitems.h index cd5cb8cec..57263a356 100644 --- a/libretroshare/src/serialiser/rsbanlistitems.h +++ b/libretroshare/src/serialiser/rsbanlistitems.h @@ -77,7 +77,7 @@ class RsBanListSerialiser: public RsSerializer public: RsBanListSerialiser() :RsSerializer(RS_SERVICE_TYPE_BANLIST) {} - virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) ; + virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) const ; }; /**************************************************************************/ diff --git a/libretroshare/src/serialiser/rsbwctrlitems.cc b/libretroshare/src/serialiser/rsbwctrlitems.cc index bd1f0341e..092b1d643 100644 --- a/libretroshare/src/serialiser/rsbwctrlitems.cc +++ b/libretroshare/src/serialiser/rsbwctrlitems.cc @@ -34,7 +34,7 @@ /*************************************************************************/ -RsItem *RsBwCtrlSerialiser::create_item(uint16_t service, uint8_t item_sub_id) +RsItem *RsBwCtrlSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const { if(service != RS_SERVICE_TYPE_BWCTRL) return NULL ; diff --git a/libretroshare/src/serialiser/rsbwctrlitems.h b/libretroshare/src/serialiser/rsbwctrlitems.h index 8b5cc8299..07907c709 100644 --- a/libretroshare/src/serialiser/rsbwctrlitems.h +++ b/libretroshare/src/serialiser/rsbwctrlitems.h @@ -63,7 +63,7 @@ public: RsBwCtrlSerialiser() :RsSerializer(RS_SERVICE_TYPE_BWCTRL) {} virtual ~RsBwCtrlSerialiser() {} - RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */); + RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const; }; /**************************************************************************/ diff --git a/libretroshare/src/serialiser/rsfiletransferitems.cc b/libretroshare/src/serialiser/rsfiletransferitems.cc index 0be0412b7..3eb7c1147 100644 --- a/libretroshare/src/serialiser/rsfiletransferitems.cc +++ b/libretroshare/src/serialiser/rsfiletransferitems.cc @@ -137,7 +137,7 @@ template<> void RsTypeSerializer::print_data(const std::string& n, const Compres // Serializer // //===================================================================================================// -RsItem *RsFileTransferSerialiser::create_item(uint16_t service_type,uint8_t item_type) +RsItem *RsFileTransferSerialiser::create_item(uint16_t service_type,uint8_t item_type) const { if(service_type != RS_SERVICE_TYPE_FILE_TRANSFER) return NULL ; diff --git a/libretroshare/src/serialiser/rsfiletransferitems.h b/libretroshare/src/serialiser/rsfiletransferitems.h index 50b3c2a26..ae1835126 100644 --- a/libretroshare/src/serialiser/rsfiletransferitems.h +++ b/libretroshare/src/serialiser/rsfiletransferitems.h @@ -183,7 +183,7 @@ class RsFileTransferSerialiser: public RsSerializer virtual ~RsFileTransferSerialiser() {} - RsItem *create_item(uint16_t service_type,uint8_t item_type) ; + RsItem *create_item(uint16_t service_type,uint8_t item_type) const ; }; diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 9c6259cf9..d8ff50b14 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -17,7 +17,7 @@ class RsSerializer: public RsSerialType /*! create_item * should be overloaded to create the correct type of item depending on the data */ - virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) + virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const { return NULL ; } diff --git a/libretroshare/src/turtle/rsturtleitem.cc b/libretroshare/src/turtle/rsturtleitem.cc index 577d152a8..e5d064ef2 100644 --- a/libretroshare/src/turtle/rsturtleitem.cc +++ b/libretroshare/src/turtle/rsturtleitem.cc @@ -109,7 +109,7 @@ uint32_t RsTurtleGenericDataItem::serial_size() const // // ---------------------------------- Serialization ----------------------------------// // -RsItem *RsTurtleSerialiser::create_item(uint16_t service,uint8_t item_subtype) +RsItem *RsTurtleSerialiser::create_item(uint16_t service,uint8_t item_subtype) const { if (RS_SERVICE_TYPE_TURTLE != service) { @@ -136,7 +136,7 @@ RsItem *RsTurtleSerialiser::create_item(uint16_t service,uint8_t item_subtype) RsItem *item = NULL ; for(uint32_t i=0;i<_client_services.size();++i) - if((item = _client_services[i]->create_item(service,item_subtype)) != NULL) + if((_client_services[i]->serializer() != NULL) && (item = _client_services[i]->serializer()->create_item(service,item_subtype)) != NULL) return item ; std::cerr << "Unknown packet type in RsTurtle (not even handled by client services)!" << std::endl ; diff --git a/libretroshare/src/turtle/rsturtleitem.h b/libretroshare/src/turtle/rsturtleitem.h index 22477668a..95594761b 100644 --- a/libretroshare/src/turtle/rsturtleitem.h +++ b/libretroshare/src/turtle/rsturtleitem.h @@ -23,11 +23,12 @@ const uint8_t RS_TURTLE_SUBTYPE_REGEXP_SEARCH_REQUEST = 0x09 ; const uint8_t RS_TURTLE_SUBTYPE_GENERIC_DATA = 0x0a ; const uint8_t RS_TURTLE_SUBTYPE_FILE_MAP = 0x10 ; const uint8_t RS_TURTLE_SUBTYPE_FILE_MAP_REQUEST = 0x11 ; -const uint8_t RS_TURTLE_SUBTYPE_FILE_CRC = 0x12 ; -const uint8_t RS_TURTLE_SUBTYPE_FILE_CRC_REQUEST = 0x13 ; const uint8_t RS_TURTLE_SUBTYPE_CHUNK_CRC = 0x14 ; const uint8_t RS_TURTLE_SUBTYPE_CHUNK_CRC_REQUEST = 0x15 ; +// const uint8_t RS_TURTLE_SUBTYPE_FILE_CRC = 0x12 ; // unused +// const uint8_t RS_TURTLE_SUBTYPE_FILE_CRC_REQUEST = 0x13 ; + /***********************************************************************************/ /* Basic Turtle Item Class */ /***********************************************************************************/ @@ -209,7 +210,7 @@ class RsTurtleSerialiser: public RsSerializer public: RsTurtleSerialiser() : RsSerializer(RS_SERVICE_TYPE_TURTLE) {} - virtual RsItem *create_item(uint16_t service,uint8_t item_subtype); + virtual RsItem *create_item(uint16_t service,uint8_t item_subtype) const; // This is used by the turtle router to add services to its serialiser. // Client services are only used for deserialising, since the serialisation is diff --git a/libretroshare/src/turtle/turtleclientservice.h b/libretroshare/src/turtle/turtleclientservice.h index 6fa4dd629..7fa4d8b18 100644 --- a/libretroshare/src/turtle/turtleclientservice.h +++ b/libretroshare/src/turtle/turtleclientservice.h @@ -76,7 +76,7 @@ class RsTurtleClientService // services might only use the generic item already provided by the turtle // router: RsTurtleGenericDataItem - virtual RsTurtleGenericTunnelItem *create_item(uint16_t service,uint8_t item_type) const { return NULL ; } + virtual RsSerializer *serializer() { return NULL ; } // These methods are called by the turtle router to add/remove virtual peers when tunnels are created/deleted // From 2ca46ec636bef771616be789a538739199a4637f Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 16 Apr 2017 20:11:54 +0200 Subject: [PATCH 25/94] fixed bug in serialization of data chunks --- libretroshare/src/serialization/rstypeserializer.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libretroshare/src/serialization/rstypeserializer.cc b/libretroshare/src/serialization/rstypeserializer.cc index 2c68d2c0c..64ba46f68 100644 --- a/libretroshare/src/serialization/rstypeserializer.cc +++ b/libretroshare/src/serialization/rstypeserializer.cc @@ -213,6 +213,7 @@ template<> bool RsTypeSerializer::deserialize(const uint8_t data[],uint32_t size ok = ok && NULL != r.first; memcpy(r.first,&data[offset],r.second) ; + offset += r.second ; if(!ok) offset = saved_offset ; @@ -227,6 +228,7 @@ template<> bool RsTypeSerializer::serialize(uint8_t data[],uint32_t size,uint32_ bool ok = serialize(data,size,offset,r.second) ; memcpy(&data[offset],r.first,r.second) ; + offset += r.second ; if(!ok) offset = saved_offset ; From f8fc8b40e4a26c6556a394abd664fffa21e4eb7d Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 16 Apr 2017 20:16:59 +0200 Subject: [PATCH 26/94] removed old code in turtle serialiser --- .../src/serialization/rsserializer.cc | 8 +- libretroshare/src/turtle/rsturtleitem.cc | 633 ------------------ 2 files changed, 7 insertions(+), 634 deletions(-) diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index 4cf03d133..13b4435fd 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -20,6 +20,12 @@ RsItem *RsSerializer::deserialise(void *data, uint32_t *size) item->serial_process(RsItem::DESERIALIZE, ctx) ; + if(ctx.mSize != ctx.mOffset) + { + std::cerr << "RsSerializer::deserialise(): ERROR. offset does not match expected size!" << std::endl; + delete item ; + return NULL ; + } if(ctx.mOk) return item ; @@ -48,7 +54,7 @@ bool RsSerializer::serialise(RsItem *item,void *data,uint32_t *size) if(ctx.mSize != ctx.mOffset) { - std::cerr << "RsSerializer::serialise_item(): ERROR. offset does not match expected size!" << std::endl; + std::cerr << "RsSerializer::serialise(): ERROR. offset does not match expected size!" << std::endl; return false ; } return true ; diff --git a/libretroshare/src/turtle/rsturtleitem.cc b/libretroshare/src/turtle/rsturtleitem.cc index e5d064ef2..4d5f1a2fa 100644 --- a/libretroshare/src/turtle/rsturtleitem.cc +++ b/libretroshare/src/turtle/rsturtleitem.cc @@ -14,101 +14,6 @@ // -----------------------------------------------------------------------------------// // -// -// ---------------------------------- Packet sizes -----------------------------------// -// - -#ifdef TO_REMOVE -uint32_t RsTurtleStringSearchRequestItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // request_id - s += 2 ; // depth - s += GetTlvStringSize(match_string) ; // match_string - - return s ; -} -uint32_t RsTurtleRegExpSearchRequestItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // request_id - s += 2 ; // depth - - s += 4 ; // number of strings - - for(unsigned int i=0;i::const_iterator it(result.begin());it!=result.end();++it) - { - s += 8 ; // file size - s += it->hash.serial_size(); // file hash - s += GetTlvStringSize(it->name) ; // file name - } - - return s ; -} - -uint32_t RsTurtleOpenTunnelItem::serial_size()const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += file_hash.serial_size() ; // file hash - s += 4 ; // tunnel request id - s += 4 ; // partial tunnel id - s += 2 ; // depth - - return s ; -} - -uint32_t RsTurtleTunnelOkItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 4 ; // tunnel request id - - return s ; -} - -uint32_t RsTurtleGenericDataItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 4 ; // data size - s += data_size ; // data - - return s ; -} -#endif -// -// ---------------------------------- Serialization ----------------------------------// -// RsItem *RsTurtleSerialiser::create_item(uint16_t service,uint8_t item_subtype) const { if (RS_SERVICE_TYPE_TURTLE != service) @@ -150,92 +55,6 @@ void RsTurtleStringSearchRequestItem::serial_process(SerializeJob j,SerializeCon RsTypeSerializer::serial_process(j,ctx,depth ,"depth") ; } -#ifdef TO_REMOVE -bool RsTurtleStringSearchRequestItem::serialize(void *data,uint32_t& pktsize) const -{ - 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; - - /* add mandatory parts first */ - - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, match_string); - ok &= setRawUInt32(data, tlvsize, &offset, request_id); - ok &= setRawUInt16(data, tlvsize, &offset, depth); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileConfigSerialiser::serialiseTransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} - -bool RsTurtleRegExpSearchRequestItem::serialize(void *data,uint32_t& pktsize) const -{ - uint32_t tlvsize = serial_size(); - uint32_t offset = 0; - -#ifdef P3TURTLE_DEBUG - std::cerr << "RsTurtleSerialiser::serialising RegExp search packet (size=" << tlvsize << ")" << std::endl; -#endif - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data,tlvsize,PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - - ok &= setRawUInt32(data, tlvsize, &offset, request_id); - ok &= setRawUInt16(data, tlvsize, &offset, depth); - - // now serialize the regexp - ok &= setRawUInt32(data,tlvsize,&offset,expr._tokens.size()) ; - - for(unsigned int i=0;i(j,ctx,request_id,"request_id") ; @@ -321,76 +140,6 @@ template<> void RsTypeSerializer::print_data(const std::string& n, const RsRegul std::cerr << " [RegExpr ] " << n << ", tokens=" << expr._tokens.size() << " ints=" << expr._ints.size() << " strings=" << expr._strings.size() << std::endl; } - -#ifdef TO_REMOVE -RsTurtleStringSearchRequestItem::RsTurtleStringSearchRequestItem(void *data,uint32_t pktsize) - : RsTurtleSearchRequestItem(RS_TURTLE_SUBTYPE_STRING_SEARCH_REQUEST) -{ -#ifdef P3TURTLE_DEBUG - std::cerr << " deserializibg packet. type = search request (string)" << std::endl ; -#endif - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, match_string); // file hash - ok &= getRawUInt32(data, pktsize, &offset, &request_id); - ok &= getRawUInt16(data, pktsize, &offset, &depth); - -#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs). - UNREFERENCED_LOCAL_VARIABLE(rssize); -#else - if (offset != rssize) - throw std::runtime_error("Size error while deserializing.") ; - if (!ok) - throw std::runtime_error("Unknown error while deserializing.") ; -#endif -} - -RsTurtleRegExpSearchRequestItem::RsTurtleRegExpSearchRequestItem(void *data,uint32_t pktsize) - : RsTurtleSearchRequestItem(RS_TURTLE_SUBTYPE_REGEXP_SEARCH_REQUEST) -{ -#ifdef P3TURTLE_DEBUG - std::cerr << " deserializibg packet. type = search request (regexp)" << std::endl ; -#endif - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - ok &= getRawUInt32(data, pktsize, &offset, &request_id); - ok &= getRawUInt16(data, pktsize, &offset, &depth); - - // now serialize the regexp - uint32_t n =0 ; - ok &= getRawUInt32(data,pktsize,&offset,&n) ; - - if(ok) expr._tokens.resize(n) ; - - for(uint32_t i=0;i(j,ctx,request_id,"request_id") ; @@ -444,94 +193,6 @@ template<> void RsTypeSerializer::print_data(const std::string& n, const TurtleF std::cerr << " [FileInfo ] " << n << " size=" << i.size << " hash=" << i.hash << ", name=" << i.name << std::endl; } -#ifdef TO_REMOVE - -bool RsTurtleSearchResultItem::serialize(void *data,uint32_t& pktsize) const -{ - 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; - - /* add mandatory parts first */ - - ok &= setRawUInt32(data, tlvsize, &offset, request_id); - ok &= setRawUInt16(data, tlvsize, &offset, depth); - ok &= setRawUInt32(data, tlvsize, &offset, result.size()); - - for(std::list::const_iterator it(result.begin());it!=result.end();++it) - { - ok &= setRawUInt64(data, tlvsize, &offset, it->size); // file size - ok &= it->hash.serialise(data, tlvsize, offset); // file hash - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, it->name); // file name - } - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileConfigSerialiser::serialiseTransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsTurtleSearchResultItem::RsTurtleSearchResultItem(void *data,uint32_t pktsize) - : RsTurtleItem(RS_TURTLE_SUBTYPE_SEARCH_RESULT) -{ - setPriorityLevel(QOS_PRIORITY_RS_TURTLE_SEARCH_RESULT) ; -#ifdef P3TURTLE_DEBUG - std::cerr << " type = search result" << std::endl ; -#endif - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - - /* add mandatory parts first */ - - bool ok = true ; - uint32_t s ; - ok &= getRawUInt32(data, pktsize, &offset, &request_id); - ok &= getRawUInt16(data, pktsize, &offset, &depth); - ok &= getRawUInt32(data, pktsize, &offset, &s) ; -#ifdef P3TURTLE_DEBUG - std::cerr << " request_id=" << request_id << ", depth=" << depth << ", s=" << s << std::endl ; -#endif - - result.clear() ; - - for(int i=0;i<(int)s;++i) - { - TurtleFileInfo f ; - - ok &= getRawUInt64(data, pktsize, &offset, &(f.size)); // file size - ok &= f.hash.deserialise(data, pktsize, offset); // file hash - ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_NAME, f.name); // file name - - result.push_back(f) ; - } - -#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs). - UNREFERENCED_LOCAL_VARIABLE(rssize); -#else - if (offset != rssize) - throw std::runtime_error("Size error while deserializing.") ; - if (!ok) - throw std::runtime_error("Unknown error while deserializing.") ; -#endif -} -#endif - void RsTurtleOpenTunnelItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,file_hash ,"file_hash") ; @@ -540,144 +201,12 @@ void RsTurtleOpenTunnelItem::serial_process(SerializeJob j,SerializeContext& ctx RsTypeSerializer::serial_process(j,ctx,depth ,"depth") ; } -#ifdef TO_REMOVE -bool RsTurtleOpenTunnelItem::serialize(void *data,uint32_t& pktsize) const -{ - 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; - - /* add mandatory parts first */ - - ok &= file_hash.serialise(data, tlvsize, offset); // file hash - ok &= setRawUInt32(data, tlvsize, &offset, request_id); - ok &= setRawUInt32(data, tlvsize, &offset, partial_tunnel_id); - ok &= setRawUInt16(data, tlvsize, &offset, depth); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsTurtleOpenTunnelItem::serialiseTransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsTurtleOpenTunnelItem::RsTurtleOpenTunnelItem(void *data,uint32_t pktsize) - : RsTurtleItem(RS_TURTLE_SUBTYPE_OPEN_TUNNEL) -{ - setPriorityLevel(QOS_PRIORITY_RS_TURTLE_OPEN_TUNNEL) ; -#ifdef P3TURTLE_DEBUG - std::cerr << " type = open tunnel" << std::endl ; -#endif - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - - /* add mandatory parts first */ - - bool ok = true ; - ok &= file_hash.deserialise(data, pktsize, offset); // file hash - ok &= getRawUInt32(data, pktsize, &offset, &request_id); - ok &= getRawUInt32(data, pktsize, &offset, &partial_tunnel_id) ; - ok &= getRawUInt16(data, pktsize, &offset, &depth); -#ifdef P3TURTLE_DEBUG - std::cerr << " request_id=" << (void*)request_id << ", partial_id=" << (void*)partial_tunnel_id << ", depth=" << depth << ", hash=" << file_hash << std::endl ; -#endif - -#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs). - UNREFERENCED_LOCAL_VARIABLE(rssize); -#else - if (offset != rssize) - throw std::runtime_error("RsTurtleOpenTunnelItem::() error while deserializing.") ; - if (!ok) - throw std::runtime_error("RsTurtleOpenTunnelItem::() unknown error while deserializing.") ; -#endif -} -#endif - void RsTurtleTunnelOkItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id ,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; } -#ifdef TO_REMOVE -bool RsTurtleTunnelOkItem::serialize(void *data,uint32_t& pktsize) const -{ - 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; - - /* add mandatory parts first */ - - ok &= setRawUInt32(data, tlvsize, &offset, tunnel_id); - ok &= setRawUInt32(data, tlvsize, &offset, request_id); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsTurtleTunnelOkItem::serialiseTransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsTurtleTunnelOkItem::RsTurtleTunnelOkItem(void *data,uint32_t pktsize) - : RsTurtleItem(RS_TURTLE_SUBTYPE_TUNNEL_OK) -{ - setPriorityLevel(QOS_PRIORITY_RS_TURTLE_TUNNEL_OK) ; -#ifdef P3TURTLE_DEBUG - std::cerr << " type = tunnel ok" << std::endl ; -#endif - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - - /* add mandatory parts first */ - - bool ok = true ; - ok &= getRawUInt32(data, pktsize, &offset, &tunnel_id) ; - ok &= getRawUInt32(data, pktsize, &offset, &request_id); -#ifdef P3TURTLE_DEBUG - std::cerr << " request_id=" << (void*)request_id << ", tunnel_id=" << (void*)tunnel_id << std::endl ; -#endif - -#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs). - UNREFERENCED_LOCAL_VARIABLE(rssize); -#else - if (offset != rssize) - throw std::runtime_error("RsTurtleTunnelOkItem::() error while deserializing.") ; - if (!ok) - throw std::runtime_error("RsTurtleTunnelOkItem::() unknown error while deserializing.") ; -#endif -} -#endif - void RsTurtleGenericDataItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id ,"tunnel_id") ; @@ -686,165 +215,3 @@ void RsTurtleGenericDataItem::serial_process(SerializeJob j,SerializeContext& ct RsTypeSerializer::serial_process(j,ctx,prox,"data bytes") ; } - -#ifdef TO_REMOVE -RsTurtleGenericDataItem::RsTurtleGenericDataItem(void *data,uint32_t pktsize) - : RsTurtleGenericTunnelItem(RS_TURTLE_SUBTYPE_GENERIC_DATA) -{ - setPriorityLevel(QOS_PRIORITY_RS_TURTLE_GENERIC_DATA) ; -#ifdef P3TURTLE_DEBUG - std::cerr << " type = tunnel ok" << std::endl ; -#endif - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - - if(rssize > pktsize) - throw std::runtime_error("RsTurtleTunnelOkItem::() wrong rssize (exceeds pktsize).") ; - - /* add mandatory parts first */ - - bool ok = true ; - - ok &= getRawUInt32(data, pktsize, &offset, &tunnel_id) ; - ok &= getRawUInt32(data, pktsize, &offset, &data_size); -#ifdef P3TURTLE_DEBUG - std::cerr << " request_id=" << (void*)request_id << ", tunnel_id=" << (void*)tunnel_id << std::endl ; -#endif - - if(data_size > rssize || rssize - data_size < offset) - throw std::runtime_error("RsTurtleTunnelOkItem::() wrong data_size (exceeds rssize).") ; - - data_bytes = rs_malloc(data_size) ; - - if(data_bytes != NULL) - { - memcpy(data_bytes,(void *)((uint8_t *)data+offset),data_size) ; - offset += data_size ; - } - else - offset = 0 ; // generate an error - -#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs). - UNREFERENCED_LOCAL_VARIABLE(rssize); -#else - if (offset != rssize) - throw std::runtime_error("RsTurtleTunnelOkItem::() error while deserializing.") ; - if (!ok) - throw std::runtime_error("RsTurtleTunnelOkItem::() unknown error while deserializing.") ; -#endif -} - -bool RsTurtleGenericDataItem::serialize(void *data,uint32_t& pktsize) const -{ - 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; - - /* add mandatory parts first */ - - ok &= setRawUInt32(data, tlvsize, &offset, tunnel_id); - ok &= setRawUInt32(data, tlvsize, &offset, data_size); - - memcpy((void *)((uint8_t *)data+offset),data_bytes,data_size) ; - offset += data_size ; - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsTurtleTunnelOkItem::serialiseTransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} - -// -----------------------------------------------------------------------------------// -// ------------------------------------- IO --------------------------------------- // -// -----------------------------------------------------------------------------------// -// -std::ostream& RsTurtleStringSearchRequestItem::print(std::ostream& o, uint16_t) -{ - o << "Search request (string):" << std::endl ; - o << " direct origin: \"" << PeerId() << "\"" << std::endl ; - o << " match string: \"" << match_string << "\"" << std::endl ; - o << " Req. Id: " << std::hex << request_id << std::dec << std::endl ; - o << " Depth : " << depth << std::endl ; - - return o ; -} -std::ostream& RsTurtleRegExpSearchRequestItem::print(std::ostream& o, uint16_t) -{ - o << "Search request (regexp):" << std::endl ; - o << " direct origin: \"" << PeerId() << "\"" << std::endl ; - o << " Req. Id: " << std::hex << request_id << std::dec << std::endl ; - o << " Depth : " << depth << std::endl ; - o << " RegExp: " << std::endl ; - o << " Toks: " ; for(unsigned int i=0;i::const_iterator it(result.begin());it!=result.end();++it) - o << " " << it->hash << " " << it->size << " " << it->name << std::endl ; - - return o ; -} - -std::ostream& RsTurtleOpenTunnelItem::print(std::ostream& o, uint16_t) -{ - o << "Open Tunnel:" << std::endl ; - - o << " Peer id : " << PeerId() << std::endl ; - o << " Partial tId: " << std::hex << partial_tunnel_id << std::dec << std::endl ; - o << " Req. Id : " << std::hex << request_id << std::dec << std::endl ; - o << " Depth : " << depth << std::endl ; - o << " Hash : " << file_hash << std::endl ; - - return o ; -} - -std::ostream& RsTurtleTunnelOkItem::print(std::ostream& o, uint16_t) -{ - o << "Tunnel Ok:" << std::endl ; - - o << " Peer id : " << PeerId() << std::endl ; - o << " tunnel id : " << std::hex << tunnel_id << std::dec << std::endl ; - o << " Req. Id : " << std::hex << request_id << std::dec << std::endl ; - - return o ; -} - -std::ostream& RsTurtleGenericDataItem::print(std::ostream& o, uint16_t) -{ - o << "Generic Data item:" << std::endl ; - - o << " Peer id : " << PeerId() << std::endl ; - o << " data size : " << data_size << std::endl ; - o << " data bytes: " << std::hex << (void*)data_bytes << std::dec << std::endl ; - - return o ; -} -#endif From e2d9152b226bc003d9c1d64d54ea7e9e96609f10 Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 18 Apr 2017 21:11:37 +0200 Subject: [PATCH 27/94] moved converted serialisation files into new directory rsitems/, leaving serialiser/ for the serialisation classes --- libretroshare/src/chat/rschatitems.h | 2 +- libretroshare/src/file_sharing/p3filelists.cc | 2 +- .../src/file_sharing/rsfilelistitems.h | 2 +- libretroshare/src/ft/ftserver.cc | 4 +- .../src/ft/ftturtlefiletransferitem.cc | 542 +----------------- libretroshare/src/grouter/grouteritems.h | 2 +- .../src/gxstunnel/rsgxstunnelitems.h | 2 +- libretroshare/src/libretroshare.pro | 16 +- libretroshare/src/pqi/p3servicecontrol.cc | 2 +- .../{serialiser => rsitems}/itempriorities.h | 0 .../{serialiser => rsitems}/rsbanlistitems.cc | 2 +- .../{serialiser => rsitems}/rsbanlistitems.h | 2 +- .../{serialiser => rsitems}/rsbwctrlitems.cc | 2 +- .../{serialiser => rsitems}/rsbwctrlitems.h | 2 +- .../rsfiletransferitems.cc | 2 +- .../rsfiletransferitems.h | 2 +- .../{serialiser => rsitems}/rsserviceids.h | 0 .../src/serialiser/rsdiscovery2items.cc | 2 +- .../src/serialiser/rsdiscovery2items.h | 2 +- libretroshare/src/serialiser/rsdsdvitems.h | 2 +- .../src/serialiser/rsgxschannelitems.h | 2 +- .../src/serialiser/rsgxscircleitems.h | 2 +- .../src/serialiser/rsgxscommentitems.h | 2 +- .../src/serialiser/rsgxsforumitems.h | 2 +- libretroshare/src/serialiser/rsgxsiditems.h | 2 +- libretroshare/src/serialiser/rsgxsitems.h | 2 +- .../src/serialiser/rsgxsrecognitems.h | 2 +- .../src/serialiser/rsgxsreputationitems.h | 2 +- .../src/serialiser/rsgxsupdateitems.h | 2 +- .../src/serialiser/rsheartbeatitems.cc | 2 +- .../src/serialiser/rsheartbeatitems.h | 2 +- libretroshare/src/serialiser/rshistoryitems.h | 2 +- libretroshare/src/serialiser/rsmsgitems.h | 2 +- libretroshare/src/serialiser/rsnxsitems.h | 2 +- libretroshare/src/serialiser/rsphotoitems.h | 2 +- libretroshare/src/serialiser/rsposteditems.h | 2 +- libretroshare/src/serialiser/rsrttitems.h | 2 +- libretroshare/src/serialiser/rsserial.h | 2 +- .../src/serialiser/rsserviceinfoitems.h | 2 +- libretroshare/src/serialiser/rsstatusitems.h | 2 +- libretroshare/src/serialiser/rswikiitems.h | 2 +- libretroshare/src/serialiser/rswireitems.h | 2 +- libretroshare/src/services/p3banlist.cc | 2 +- libretroshare/src/services/p3banlist.h | 2 +- libretroshare/src/services/p3bwctrl.cc | 2 +- libretroshare/src/services/p3bwctrl.h | 2 +- libretroshare/src/services/p3serviceinfo.cc | 2 +- libretroshare/src/turtle/rsturtleitem.h | 2 +- plugins/FeedReader/FeedReaderPlugin.h | 2 +- .../FeedReader/services/rsFeedReaderItems.h | 2 +- plugins/VOIP/services/rsVOIPItems.h | 2 +- .../services/gxs/rsgxstestitems.h | 2 +- 52 files changed, 58 insertions(+), 598 deletions(-) rename libretroshare/src/{serialiser => rsitems}/itempriorities.h (100%) rename libretroshare/src/{serialiser => rsitems}/rsbanlistitems.cc (98%) rename libretroshare/src/{serialiser => rsitems}/rsbanlistitems.h (98%) rename libretroshare/src/{serialiser => rsitems}/rsbwctrlitems.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rsbwctrlitems.h (98%) rename libretroshare/src/{serialiser => rsitems}/rsfiletransferitems.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rsfiletransferitems.h (99%) rename libretroshare/src/{serialiser => rsitems}/rsserviceids.h (100%) diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 7771a375f..456ffe5b6 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -29,7 +29,7 @@ #include "retroshare/rstypes.h" #include "serialization/rsserializer.h" #include "serialiser/rstlvkeys.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" diff --git a/libretroshare/src/file_sharing/p3filelists.cc b/libretroshare/src/file_sharing/p3filelists.cc index 2c30b6813..492c37f67 100644 --- a/libretroshare/src/file_sharing/p3filelists.cc +++ b/libretroshare/src/file_sharing/p3filelists.cc @@ -22,7 +22,7 @@ * Please report all bugs and problems to "retroshare.project@gmail.com". * */ -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "file_sharing/p3filelists.h" #include "file_sharing/directory_storage.h" diff --git a/libretroshare/src/file_sharing/rsfilelistitems.h b/libretroshare/src/file_sharing/rsfilelistitems.h index 8c1d466e1..d56827527 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.h +++ b/libretroshare/src/file_sharing/rsfilelistitems.h @@ -27,7 +27,7 @@ #include #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvitem.h" diff --git a/libretroshare/src/ft/ftserver.cc b/libretroshare/src/ft/ftserver.cc index 5b04f2828..9dcc139d4 100644 --- a/libretroshare/src/ft/ftserver.cc +++ b/libretroshare/src/ft/ftserver.cc @@ -49,8 +49,8 @@ const int ftserverzone = 29539; #include "pqi/pqi.h" #include "pqi/p3linkmgr.h" -#include "serialiser/rsfiletransferitems.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsfiletransferitems.h" +#include "rsitems/rsserviceids.h" /*** * #define SERVER_DEBUG 1 diff --git a/libretroshare/src/ft/ftturtlefiletransferitem.cc b/libretroshare/src/ft/ftturtlefiletransferitem.cc index 722991aef..5c343b7fa 100644 --- a/libretroshare/src/ft/ftturtlefiletransferitem.cc +++ b/libretroshare/src/ft/ftturtlefiletransferitem.cc @@ -27,557 +27,17 @@ #include #include -#include +#include #include #include -#ifdef TO_REMOVE -uint32_t RsTurtleFileRequestItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 8 ; // file offset - s += 4 ; // chunk size - - return s ; -} - -uint32_t RsTurtleFileDataItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 8 ; // file offset - s += 4 ; // chunk size - s += chunk_size ; // actual data size. - - return s ; -} - -uint32_t RsTurtleFileMapRequestItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 4 ; // direction - - return s ; -} - -uint32_t RsTurtleFileMapItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 4 ; // direction - s += 4 ; // compressed_map.size() - - s += 4 * compressed_map._map.size() ; - - return s ; -} - -uint32_t RsTurtleChunkCrcItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 4 ; // chunk number - s += check_sum.serial_size() ; // check_sum - - return s ; -} -uint32_t RsTurtleChunkCrcRequestItem::serial_size() const -{ - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 4 ; // chunk number - - return s ; -} -#endif - void RsTurtleFileMapRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,direction,"direction") ; } -#ifdef TO_REMOVE -bool RsTurtleFileMapRequestItem::serialize(void *data,uint32_t& pktsize) const -{ - 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; - - /* add mandatory parts first */ - - ok &= setRawUInt32(data, tlvsize, &offset, tunnel_id); - ok &= setRawUInt32(data, tlvsize, &offset, direction); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileConfigSerialiser::serialiseTransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} - - -bool RsTurtleFileMapItem::serialize(void *data,uint32_t& pktsize) const -{ - 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; - - /* add mandatory parts first */ - - ok &= setRawUInt32(data, tlvsize, &offset, tunnel_id); - ok &= setRawUInt32(data, tlvsize, &offset, direction); - ok &= setRawUInt32(data, tlvsize, &offset, compressed_map._map.size()); - - for(uint32_t i=0;i pktsize) - ok = false ; - - /* add mandatory parts first */ - ok &= getRawUInt32(data, pktsize, &offset, &tunnel_id) ; - ok &= getRawUInt64(data, pktsize, &offset, &chunk_offset); - ok &= getRawUInt32(data, pktsize, &offset, &chunk_size); - - if(chunk_size > rssize || rssize - chunk_size < offset) - throw std::runtime_error("RsTurtleFileDataItem::() error while deserializing.") ; - - chunk_data = (void*)rs_malloc(chunk_size) ; - - if(chunk_data == NULL) - throw std::runtime_error("RsTurtleFileDataItem::() cannot allocate memory.") ; - - memcpy(chunk_data,(void*)((unsigned char*)data+offset),chunk_size) ; - - offset += chunk_size ; - -#ifdef P3TURTLE_DEBUG - std::cerr << " tunnel_id=" << (void*)tunnel_id << ", chunk_offset=" << chunk_offset << ", chunk_size=" << chunk_size << std::endl ; -#endif - -#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs). - UNREFERENCED_LOCAL_VARIABLE(rssize); -#else - if (offset != rssize) - throw std::runtime_error("RsTurtleFileDataItem::() error while deserializing.") ; - if (!ok) - throw std::runtime_error("RsTurtleFileDataItem::() unknown error while deserializing.") ; -#endif -} - -bool RsTurtleFileDataItem::serialize(void *data,uint32_t& pktsize) const -{ - 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; - - /* add mandatory parts first */ - - ok &= setRawUInt32(data, tlvsize, &offset, tunnel_id) ; - ok &= setRawUInt64(data, tlvsize, &offset, chunk_offset); - ok &= setRawUInt32(data, tlvsize, &offset, chunk_size); - - memcpy((void*)((unsigned char*)data+offset),chunk_data,chunk_size) ; - offset += chunk_size ; - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsTurtleTunnelOkItem::serialiseTransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} -std::ostream& RsTurtleFileRequestItem::print(std::ostream& o, uint16_t) -{ - o << "File request item:" << std::endl ; - - o << " tunnel id : " << std::hex << tunnel_id << std::dec << std::endl ; - o << " offset : " << chunk_offset << std::endl ; - o << " chunk size: " << chunk_size << std::endl ; - - return o ; -} - -std::ostream& RsTurtleFileDataItem::print(std::ostream& o, uint16_t) -{ - o << "File request item:" << std::endl ; - - o << " tunnel id : " << std::hex << tunnel_id << std::dec << std::endl ; - o << " offset : " << chunk_offset << std::endl ; - o << " chunk size: " << chunk_size << std::endl ; - o << " data : " << std::hex << chunk_data << std::dec << std::endl ; - - return o ; -} - -std::ostream& RsTurtleFileMapItem::print(std::ostream& o, uint16_t) -{ - o << "File map item:" << std::endl ; - - o << " tunnel id : " << std::hex << tunnel_id << std::dec << std::endl ; - o << " direction : " << direction << std::endl ; - o << " map : " ; - - for(uint32_t i=0;i(j,ctx,tunnel_id,"tunnel_id") ; diff --git a/libretroshare/src/grouter/grouteritems.h b/libretroshare/src/grouter/grouteritems.h index a0c3dd9e7..af78866c0 100644 --- a/libretroshare/src/grouter/grouteritems.h +++ b/libretroshare/src/grouter/grouteritems.h @@ -29,7 +29,7 @@ #include "serialiser/rsserial.h" #include "serialiser/rstlvkeys.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "retroshare/rstypes.h" #include "retroshare/rsgrouter.h" diff --git a/libretroshare/src/gxstunnel/rsgxstunnelitems.h b/libretroshare/src/gxstunnel/rsgxstunnelitems.h index c23a8b9a1..ad049a753 100644 --- a/libretroshare/src/gxstunnel/rsgxstunnelitems.h +++ b/libretroshare/src/gxstunnel/rsgxstunnelitems.h @@ -29,7 +29,7 @@ #include "retroshare/rstypes.h" #include "serialiser/rstlvkeys.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 1b437282c..2d7a966e9 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -452,15 +452,15 @@ HEADERS += grouter/groutercache.h \ grouter/groutertypes.h \ grouter/rsgrouterclient.h -HEADERS += serialiser/itempriorities.h \ +HEADERS += rsitems/itempriorities.h \ serialiser/rsbaseserial.h \ - serialiser/rsfiletransferitems.h \ + rsitems/rsfiletransferitems.h \ serialiser/rsserviceserialiser.h \ serialiser/rsconfigitems.h \ serialiser/rshistoryitems.h \ serialiser/rsmsgitems.h \ serialiser/rsserial.h \ - serialiser/rsserviceids.h \ + rsitems/rsserviceids.h \ serialiser/rsserviceitems.h \ serialiser/rsstatusitems.h \ serialiser/rstlvaddrs.h \ @@ -479,8 +479,8 @@ HEADERS += serialiser/itempriorities.h \ serialiser/rstlvlist.h \ serialiser/rstlvmaps.h \ serialiser/rstlvbanlist.h \ - serialiser/rsbanlistitems.h \ - serialiser/rsbwctrlitems.h \ + rsitems/rsbanlistitems.h \ + rsitems/rsbwctrlitems.h \ serialiser/rsdiscovery2items.h \ serialiser/rsheartbeatitems.h \ serialiser/rsrttitems.h \ @@ -608,7 +608,7 @@ SOURCES += plugins/pluginmanager.cc \ serialiser/rspluginitems.cc SOURCES += serialiser/rsbaseserial.cc \ - serialiser/rsfiletransferitems.cc \ + rsitems/rsfiletransferitems.cc \ serialiser/rsserviceserialiser.cc \ serialiser/rsconfigitems.cc \ serialiser/rshistoryitems.cc \ @@ -627,8 +627,8 @@ SOURCES += serialiser/rsbaseserial.cc \ serialiser/rstlvkeyvalue.cc \ serialiser/rstlvgenericparam.cc \ serialiser/rstlvbanlist.cc \ - serialiser/rsbanlistitems.cc \ - serialiser/rsbwctrlitems.cc \ + rsitems/rsbanlistitems.cc \ + rsitems/rsbwctrlitems.cc \ serialiser/rsdiscovery2items.cc \ serialiser/rsheartbeatitems.cc \ serialiser/rsrttitems.cc \ diff --git a/libretroshare/src/pqi/p3servicecontrol.cc b/libretroshare/src/pqi/p3servicecontrol.cc index a397a4e1c..f22cc44c0 100644 --- a/libretroshare/src/pqi/p3servicecontrol.cc +++ b/libretroshare/src/pqi/p3servicecontrol.cc @@ -26,7 +26,7 @@ #include #include "p3servicecontrol.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rsbaseserial.h" #include "pqi/p3cfgmgr.h" diff --git a/libretroshare/src/serialiser/itempriorities.h b/libretroshare/src/rsitems/itempriorities.h similarity index 100% rename from libretroshare/src/serialiser/itempriorities.h rename to libretroshare/src/rsitems/itempriorities.h diff --git a/libretroshare/src/serialiser/rsbanlistitems.cc b/libretroshare/src/rsitems/rsbanlistitems.cc similarity index 98% rename from libretroshare/src/serialiser/rsbanlistitems.cc rename to libretroshare/src/rsitems/rsbanlistitems.cc index c28399e34..d597abcfd 100644 --- a/libretroshare/src/serialiser/rsbanlistitems.cc +++ b/libretroshare/src/rsitems/rsbanlistitems.cc @@ -24,7 +24,7 @@ */ #include "serialiser/rsbaseserial.h" -#include "serialiser/rsbanlistitems.h" +#include "rsitems/rsbanlistitems.h" #include "serialization/rstypeserializer.h" diff --git a/libretroshare/src/serialiser/rsbanlistitems.h b/libretroshare/src/rsitems/rsbanlistitems.h similarity index 98% rename from libretroshare/src/serialiser/rsbanlistitems.h rename to libretroshare/src/rsitems/rsbanlistitems.h index 57263a356..cc3f96eeb 100644 --- a/libretroshare/src/serialiser/rsbanlistitems.h +++ b/libretroshare/src/rsitems/rsbanlistitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rstlvbanlist.h" #include "serialization/rsserializer.h" diff --git a/libretroshare/src/serialiser/rsbwctrlitems.cc b/libretroshare/src/rsitems/rsbwctrlitems.cc similarity index 99% rename from libretroshare/src/serialiser/rsbwctrlitems.cc rename to libretroshare/src/rsitems/rsbwctrlitems.cc index 092b1d643..747dbbbda 100644 --- a/libretroshare/src/serialiser/rsbwctrlitems.cc +++ b/libretroshare/src/rsitems/rsbwctrlitems.cc @@ -24,7 +24,7 @@ */ #include "serialiser/rsbaseserial.h" -#include "serialiser/rsbwctrlitems.h" +#include "rsitems/rsbwctrlitems.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/serialiser/rsbwctrlitems.h b/libretroshare/src/rsitems/rsbwctrlitems.h similarity index 98% rename from libretroshare/src/serialiser/rsbwctrlitems.h rename to libretroshare/src/rsitems/rsbwctrlitems.h index 07907c709..e9262cd5b 100644 --- a/libretroshare/src/serialiser/rsbwctrlitems.h +++ b/libretroshare/src/rsitems/rsbwctrlitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" diff --git a/libretroshare/src/serialiser/rsfiletransferitems.cc b/libretroshare/src/rsitems/rsfiletransferitems.cc similarity index 99% rename from libretroshare/src/serialiser/rsfiletransferitems.cc rename to libretroshare/src/rsitems/rsfiletransferitems.cc index 3eb7c1147..acdadaff2 100644 --- a/libretroshare/src/serialiser/rsfiletransferitems.cc +++ b/libretroshare/src/rsitems/rsfiletransferitems.cc @@ -26,7 +26,7 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" -#include "serialiser/rsfiletransferitems.h" +#include "rsitems/rsfiletransferitems.h" #include "serialization/rstypeserializer.h" diff --git a/libretroshare/src/serialiser/rsfiletransferitems.h b/libretroshare/src/rsitems/rsfiletransferitems.h similarity index 99% rename from libretroshare/src/serialiser/rsfiletransferitems.h rename to libretroshare/src/rsitems/rsfiletransferitems.h index ae1835126..5cfed03b9 100644 --- a/libretroshare/src/serialiser/rsfiletransferitems.h +++ b/libretroshare/src/rsitems/rsfiletransferitems.h @@ -30,7 +30,7 @@ #include "retroshare/rstypes.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvfileitem.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialization/rsserializer.h" diff --git a/libretroshare/src/serialiser/rsserviceids.h b/libretroshare/src/rsitems/rsserviceids.h similarity index 100% rename from libretroshare/src/serialiser/rsserviceids.h rename to libretroshare/src/rsitems/rsserviceids.h diff --git a/libretroshare/src/serialiser/rsdiscovery2items.cc b/libretroshare/src/serialiser/rsdiscovery2items.cc index 611a7e80a..90b4313b3 100644 --- a/libretroshare/src/serialiser/rsdiscovery2items.cc +++ b/libretroshare/src/serialiser/rsdiscovery2items.cc @@ -29,7 +29,7 @@ #if 0 -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvtypes.h" diff --git a/libretroshare/src/serialiser/rsdiscovery2items.h b/libretroshare/src/serialiser/rsdiscovery2items.h index dad0d0fb5..26bbf1f22 100644 --- a/libretroshare/src/serialiser/rsdiscovery2items.h +++ b/libretroshare/src/serialiser/rsdiscovery2items.h @@ -31,7 +31,7 @@ #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" #include "serialiser/rstlvaddrs.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" const uint8_t RS_PKT_SUBTYPE_DISC_PGP_LIST = 0x01; const uint8_t RS_PKT_SUBTYPE_DISC_PGP_CERT = 0x02; diff --git a/libretroshare/src/serialiser/rsdsdvitems.h b/libretroshare/src/serialiser/rsdsdvitems.h index efafa1f4b..fd03be486 100644 --- a/libretroshare/src/serialiser/rsdsdvitems.h +++ b/libretroshare/src/serialiser/rsdsdvitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvbinary.h" diff --git a/libretroshare/src/serialiser/rsgxschannelitems.h b/libretroshare/src/serialiser/rsgxschannelitems.h index f7386b93d..9a937e581 100644 --- a/libretroshare/src/serialiser/rsgxschannelitems.h +++ b/libretroshare/src/serialiser/rsgxschannelitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.h" #include "serialiser/rstlvfileitem.h" diff --git a/libretroshare/src/serialiser/rsgxscircleitems.h b/libretroshare/src/serialiser/rsgxscircleitems.h index 4ae4e7109..84316b133 100644 --- a/libretroshare/src/serialiser/rsgxscircleitems.h +++ b/libretroshare/src/serialiser/rsgxscircleitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvitem.h" #include "serialiser/rstlvstring.h" diff --git a/libretroshare/src/serialiser/rsgxscommentitems.h b/libretroshare/src/serialiser/rsgxscommentitems.h index 6f5d1bddd..2ccd6d5d8 100644 --- a/libretroshare/src/serialiser/rsgxscommentitems.h +++ b/libretroshare/src/serialiser/rsgxscommentitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.h" diff --git a/libretroshare/src/serialiser/rsgxsforumitems.h b/libretroshare/src/serialiser/rsgxsforumitems.h index f4bce076d..97f6dd89b 100644 --- a/libretroshare/src/serialiser/rsgxsforumitems.h +++ b/libretroshare/src/serialiser/rsgxsforumitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.h" diff --git a/libretroshare/src/serialiser/rsgxsiditems.h b/libretroshare/src/serialiser/rsgxsiditems.h index 483916055..39ca6882a 100644 --- a/libretroshare/src/serialiser/rsgxsiditems.h +++ b/libretroshare/src/serialiser/rsgxsiditems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "rsgxsitems.h" diff --git a/libretroshare/src/serialiser/rsgxsitems.h b/libretroshare/src/serialiser/rsgxsitems.h index 4e46a39a4..ed6d3124d 100644 --- a/libretroshare/src/serialiser/rsgxsitems.h +++ b/libretroshare/src/serialiser/rsgxsitems.h @@ -26,7 +26,7 @@ * */ -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.h" //#include "serialiser/rstlvkeys.h" diff --git a/libretroshare/src/serialiser/rsgxsrecognitems.h b/libretroshare/src/serialiser/rsgxsrecognitems.h index a8aad7c31..6d0ea0ae6 100644 --- a/libretroshare/src/serialiser/rsgxsrecognitems.h +++ b/libretroshare/src/serialiser/rsgxsrecognitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvkeys.h" #include "serialiser/rstlvidset.h" diff --git a/libretroshare/src/serialiser/rsgxsreputationitems.h b/libretroshare/src/serialiser/rsgxsreputationitems.h index 0fdc40ee2..9d5383343 100644 --- a/libretroshare/src/serialiser/rsgxsreputationitems.h +++ b/libretroshare/src/serialiser/rsgxsreputationitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" #include "retroshare/rsgxsifacetypes.h" diff --git a/libretroshare/src/serialiser/rsgxsupdateitems.h b/libretroshare/src/serialiser/rsgxsupdateitems.h index b7d6f324c..7d6c89907 100644 --- a/libretroshare/src/serialiser/rsgxsupdateitems.h +++ b/libretroshare/src/serialiser/rsgxsupdateitems.h @@ -30,7 +30,7 @@ #if 0 #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvtypes.h" diff --git a/libretroshare/src/serialiser/rsheartbeatitems.cc b/libretroshare/src/serialiser/rsheartbeatitems.cc index 55f1e844a..0151525a2 100644 --- a/libretroshare/src/serialiser/rsheartbeatitems.cc +++ b/libretroshare/src/serialiser/rsheartbeatitems.cc @@ -25,7 +25,7 @@ */ #include "serialiser/rsbaseserial.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsheartbeatitems.h" /*** diff --git a/libretroshare/src/serialiser/rsheartbeatitems.h b/libretroshare/src/serialiser/rsheartbeatitems.h index cfabae2ee..5660ba373 100644 --- a/libretroshare/src/serialiser/rsheartbeatitems.h +++ b/libretroshare/src/serialiser/rsheartbeatitems.h @@ -29,7 +29,7 @@ #define RS_HEARTBEAT_ITEMS_H #include "serialiser/rsserial.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" const uint8_t RS_PKT_SUBTYPE_HEARTBEAT_PULSE = 0x01; diff --git a/libretroshare/src/serialiser/rshistoryitems.h b/libretroshare/src/serialiser/rshistoryitems.h index 039bf095f..72f186561 100644 --- a/libretroshare/src/serialiser/rshistoryitems.h +++ b/libretroshare/src/serialiser/rshistoryitems.h @@ -26,7 +26,7 @@ * */ -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "retroshare/rstypes.h" diff --git a/libretroshare/src/serialiser/rsmsgitems.h b/libretroshare/src/serialiser/rsmsgitems.h index 1a7e84cd0..0d44aa501 100644 --- a/libretroshare/src/serialiser/rsmsgitems.h +++ b/libretroshare/src/serialiser/rsmsgitems.h @@ -30,7 +30,7 @@ #include "retroshare/rstypes.h" #include "serialiser/rstlvkeys.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" diff --git a/libretroshare/src/serialiser/rsnxsitems.h b/libretroshare/src/serialiser/rsnxsitems.h index 88f0ca914..259c560a6 100644 --- a/libretroshare/src/serialiser/rsnxsitems.h +++ b/libretroshare/src/serialiser/rsnxsitems.h @@ -30,7 +30,7 @@ #include #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvitem.h" diff --git a/libretroshare/src/serialiser/rsphotoitems.h b/libretroshare/src/serialiser/rsphotoitems.h index 40fa8b32b..a935472e6 100644 --- a/libretroshare/src/serialiser/rsphotoitems.h +++ b/libretroshare/src/serialiser/rsphotoitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "rsgxsitems.h" diff --git a/libretroshare/src/serialiser/rsposteditems.h b/libretroshare/src/serialiser/rsposteditems.h index 6fa08f203..a303f0d33 100644 --- a/libretroshare/src/serialiser/rsposteditems.h +++ b/libretroshare/src/serialiser/rsposteditems.h @@ -1,7 +1,7 @@ #ifndef RSPOSTEDITEMS_H #define RSPOSTEDITEMS_H -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.h" diff --git a/libretroshare/src/serialiser/rsrttitems.h b/libretroshare/src/serialiser/rsrttitems.h index 2ebbbb51b..11a6b8889 100644 --- a/libretroshare/src/serialiser/rsrttitems.h +++ b/libretroshare/src/serialiser/rsrttitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" /**************************************************************************/ diff --git a/libretroshare/src/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index 21e0fcec7..ffa9bb855 100644 --- a/libretroshare/src/serialiser/rsserial.h +++ b/libretroshare/src/serialiser/rsserial.h @@ -60,7 +60,7 @@ ******************************************************************/ #include -#include "itempriorities.h" +#include "rsitems/itempriorities.h" const uint8_t RS_PKT_VERSION1 = 0x01; const uint8_t RS_PKT_VERSION_SERVICE = 0x02; diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.h b/libretroshare/src/serialiser/rsserviceinfoitems.h index 295ca4f6b..76b451cce 100644 --- a/libretroshare/src/serialiser/rsserviceinfoitems.h +++ b/libretroshare/src/serialiser/rsserviceinfoitems.h @@ -30,7 +30,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvgenericmap.h" diff --git a/libretroshare/src/serialiser/rsstatusitems.h b/libretroshare/src/serialiser/rsstatusitems.h index 8677c2be0..c6cc0c8b2 100644 --- a/libretroshare/src/serialiser/rsstatusitems.h +++ b/libretroshare/src/serialiser/rsstatusitems.h @@ -26,7 +26,7 @@ * */ -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" /**************************************************************************/ diff --git a/libretroshare/src/serialiser/rswikiitems.h b/libretroshare/src/serialiser/rswikiitems.h index e45eab729..4247f9d3b 100644 --- a/libretroshare/src/serialiser/rswikiitems.h +++ b/libretroshare/src/serialiser/rswikiitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.h" diff --git a/libretroshare/src/serialiser/rswireitems.h b/libretroshare/src/serialiser/rswireitems.h index 72d1732a6..77258707a 100644 --- a/libretroshare/src/serialiser/rswireitems.h +++ b/libretroshare/src/serialiser/rswireitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.h" diff --git a/libretroshare/src/services/p3banlist.cc b/libretroshare/src/services/p3banlist.cc index 157cc23f8..bf72ea815 100644 --- a/libretroshare/src/services/p3banlist.cc +++ b/libretroshare/src/services/p3banlist.cc @@ -30,7 +30,7 @@ #include "util/rsnet.h" #include "services/p3banlist.h" -#include "serialiser/rsbanlistitems.h" +#include "rsitems/rsbanlistitems.h" #include "serialiser/rsconfigitems.h" #include "retroshare/rsdht.h" #include "retroshare/rsbanlist.h" diff --git a/libretroshare/src/services/p3banlist.h b/libretroshare/src/services/p3banlist.h index 87bb7104a..7cdc983a5 100644 --- a/libretroshare/src/services/p3banlist.h +++ b/libretroshare/src/services/p3banlist.h @@ -31,7 +31,7 @@ #include #include -#include "serialiser/rsbanlistitems.h" +#include "rsitems/rsbanlistitems.h" #include "services/p3service.h" #include "retroshare/rsbanlist.h" diff --git a/libretroshare/src/services/p3bwctrl.cc b/libretroshare/src/services/p3bwctrl.cc index 1cf4da87f..aa9106e47 100644 --- a/libretroshare/src/services/p3bwctrl.cc +++ b/libretroshare/src/services/p3bwctrl.cc @@ -30,7 +30,7 @@ #include "util/rsnet.h" #include "services/p3bwctrl.h" -#include "serialiser/rsbwctrlitems.h" +#include "rsitems/rsbwctrlitems.h" #include diff --git a/libretroshare/src/services/p3bwctrl.h b/libretroshare/src/services/p3bwctrl.h index 94c746aa8..9e80bb188 100644 --- a/libretroshare/src/services/p3bwctrl.h +++ b/libretroshare/src/services/p3bwctrl.h @@ -31,7 +31,7 @@ #include #include -#include "serialiser/rsbwctrlitems.h" +#include "rsitems/rsbwctrlitems.h" #include "services/p3service.h" #include "pqi/pqiservicemonitor.h" #include "retroshare/rsconfig.h" // for datatypes. diff --git a/libretroshare/src/services/p3serviceinfo.cc b/libretroshare/src/services/p3serviceinfo.cc index 0965914e0..0782016a1 100644 --- a/libretroshare/src/services/p3serviceinfo.cc +++ b/libretroshare/src/services/p3serviceinfo.cc @@ -29,7 +29,7 @@ #include "util/rsnet.h" #include "services/p3serviceinfo.h" -#include "serialiser/rsbanlistitems.h" +#include "rsitems/rsbanlistitems.h" #include diff --git a/libretroshare/src/turtle/rsturtleitem.h b/libretroshare/src/turtle/rsturtleitem.h index 95594761b..0249cce22 100644 --- a/libretroshare/src/turtle/rsturtleitem.h +++ b/libretroshare/src/turtle/rsturtleitem.h @@ -6,7 +6,7 @@ #include "retroshare/rsturtle.h" #include "retroshare/rsexpr.h" #include "retroshare/rstypes.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "turtle/turtletypes.h" #include "serialization/rsserializer.h" diff --git a/plugins/FeedReader/FeedReaderPlugin.h b/plugins/FeedReader/FeedReaderPlugin.h index 9a27d9243..12b45db20 100644 --- a/plugins/FeedReader/FeedReaderPlugin.h +++ b/plugins/FeedReader/FeedReaderPlugin.h @@ -21,7 +21,7 @@ #pragma once -#include +#include #include #include #include "services/p3FeedReader.h" diff --git a/plugins/FeedReader/services/rsFeedReaderItems.h b/plugins/FeedReader/services/rsFeedReaderItems.h index 14f6d0e6e..da4e4fa72 100644 --- a/plugins/FeedReader/services/rsFeedReaderItems.h +++ b/plugins/FeedReader/services/rsFeedReaderItems.h @@ -22,7 +22,7 @@ #ifndef RS_FEEDREADER_ITEMS_H #define RS_FEEDREADER_ITEMS_H -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvstring.h" diff --git a/plugins/VOIP/services/rsVOIPItems.h b/plugins/VOIP/services/rsVOIPItems.h index 7d083fde5..a685f9ef6 100644 --- a/plugins/VOIP/services/rsVOIPItems.h +++ b/plugins/VOIP/services/rsVOIPItems.h @@ -48,7 +48,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" /**************************************************************************/ diff --git a/tests/unittests/libretroshare/services/gxs/rsgxstestitems.h b/tests/unittests/libretroshare/services/gxs/rsgxstestitems.h index 8a367cfc3..78379436f 100644 --- a/tests/unittests/libretroshare/services/gxs/rsgxstestitems.h +++ b/tests/unittests/libretroshare/services/gxs/rsgxstestitems.h @@ -27,7 +27,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rsgxsitems.h" From 311f257090ab6027e629357c6927d5f4e7e29ecb Mon Sep 17 00:00:00 2001 From: csoler Date: Sat, 22 Apr 2017 21:10:55 +0200 Subject: [PATCH 28/94] converted GxsReputationItems to new serialization --- .../src/serialiser/rsgxsreputationitems.cc | 91 +++++++++++++------ .../src/serialiser/rsgxsreputationitems.h | 65 ++++--------- .../src/serialization/rstypeserializer.h | 71 +++++++++++++++ libretroshare/src/services/p3gxsreputation.cc | 5 +- libretroshare/src/services/p3gxsreputation.h | 2 + 5 files changed, 156 insertions(+), 78 deletions(-) diff --git a/libretroshare/src/serialiser/rsgxsreputationitems.cc b/libretroshare/src/serialiser/rsgxsreputationitems.cc index 5701cc756..e5240d91d 100644 --- a/libretroshare/src/serialiser/rsgxsreputationitems.cc +++ b/libretroshare/src/serialiser/rsgxsreputationitems.cc @@ -28,40 +28,14 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rsgxsreputationitems.h" +#include "serialization/rstypeserializer.h" + /*** #define RSSERIAL_DEBUG 1 ***/ #include -// re-defined here, in order to avoid cross-includes -#define REPUTATION_IDENTITY_FLAG_NEEDS_UPDATE 0x0100 - -/*************************************************************************/ - -bool RsReputationItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const -{ - tlvsize = serial_size() ; - offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsReputationItem::serialise_header(): ERROR. Not enough size!" << std::endl; - return false ; - } -#ifdef RSSERIAL_DEBUG - std::cerr << "RsReputationItem::serialise() Header: " << ok << std::endl; -#endif - offset += 8; - - return true ; -} - /*************************************************************************/ void RsGxsReputationSetItem::clear() @@ -79,6 +53,45 @@ void RsGxsReputationBannedNodeSetItem::clear() mKnownIdentities.TlvClear(); } +void RsGxsReputationConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,mPeerId,"mPeerId") ; + RsTypeSerializer::serial_process(j,ctx,mLatestUpdate,"mLatestUpdate") ; + RsTypeSerializer::serial_process(j,ctx,mLastQuery,"mLastQuery") ; +} + +void RsGxsReputationBannedNodeSetItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,mPgpId,"mPgpId") ; + RsTypeSerializer::serial_process (j,ctx,mLastActivityTS,"mLastActivityTS") ; + RsTypeSerializer::serial_process(j,ctx,mKnownIdentities,"mKnownIdentities") ; +} + +void RsGxsReputationSetItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,mGxsId,"mGxsId") ; + RsTypeSerializer::serial_process(j,ctx,mOwnOpinion,"mOwnOpinion") ; + RsTypeSerializer::serial_process(j,ctx,mOwnOpinionTS,"mOwnOpinionTS") ; + RsTypeSerializer::serial_process(j,ctx,mIdentityFlags,"mIdentityFlags") ; + RsTypeSerializer::serial_process(j,ctx,mLastUsedTS,"mLastUsedTS") ; + RsTypeSerializer::serial_process (j,ctx,mOwnerNodeId,"mOwnerNodeId") ; + RsTypeSerializer::serial_process (j,ctx,mOpinions,"mOpinions") ; +} + +void RsGxsReputationUpdateItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mLatestUpdate,"mLatestUpdate") ; + RsTypeSerializer::serial_process (j,ctx,mOpinions,"mOpinions") ; +} +void RsGxsReputationRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mLastUpdate,"mLastUpdate") ; +} + +#ifdef TO_REMOVE +// re-defined here, in order to avoid cross-includes +#define REPUTATION_IDENTITY_FLAG_NEEDS_UPDATE 0x0100 + /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ @@ -360,6 +373,7 @@ RsGxsReputationConfigItem *RsGxsReputationSerialiser::deserialiseReputationConfi return item; } + RsGxsReputationBannedNodeSetItem *RsGxsReputationSerialiser::deserialiseReputationBannedNodeSetItem(void *data,uint32_t size) { uint32_t offset = 8; // skip the header @@ -382,6 +396,8 @@ RsGxsReputationBannedNodeSetItem *RsGxsReputationSerialiser::deserialiseReputati return item; } + + RsGxsReputationSetItem *RsGxsReputationSerialiser::deserialiseReputationSetItem_deprecated(void *data,uint32_t tlvsize) { uint32_t offset = 8; // skip the header @@ -502,6 +518,7 @@ RsGxsReputationSetItem *RsGxsReputationSerialiser::deserialiseReputationSetItem( return item; } + RsGxsReputationUpdateItem *RsGxsReputationSerialiser::deserialiseReputationUpdateItem(void *data,uint32_t tlvsize) { uint32_t offset = 8; // skip the header @@ -559,6 +576,7 @@ RsGxsReputationRequestItem *RsGxsReputationSerialiser::deserialiseReputationRequ return item; } + /*************************************************************************/ RsItem *RsGxsReputationSerialiser::deserialise(void *data, uint32_t *pktsize) @@ -587,8 +605,25 @@ RsItem *RsGxsReputationSerialiser::deserialise(void *data, uint32_t *pktsize) break; } } +#endif /*************************************************************************/ +RsItem *RsGxsReputationSerialiser::create_item(uint16_t service,uint8_t subtype) const +{ + if(service != RS_SERVICE_GXS_TYPE_REPUTATION) + return NULL ; + switch(subtype) + { + case RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM : return new RsGxsReputationSetItem() ; + case RS_PKT_SUBTYPE_GXS_REPUTATION_BANNED_NODE_SET_ITEM : return new RsGxsReputationBannedNodeSetItem(); + case RS_PKT_SUBTYPE_GXS_REPUTATION_UPDATE_ITEM : return new RsGxsReputationUpdateItem(); + case RS_PKT_SUBTYPE_GXS_REPUTATION_REQUEST_ITEM : return new RsGxsReputationRequestItem() ; + case RS_PKT_SUBTYPE_GXS_REPUTATION_CONFIG_ITEM : return new RsGxsReputationConfigItem () ; + default: + std::cerr << "(EE) RsGxsReputationSerialiser::create_item(): unhandled item type " << subtype << std::endl; + return NULL ; + } +} diff --git a/libretroshare/src/serialiser/rsgxsreputationitems.h b/libretroshare/src/serialiser/rsgxsreputationitems.h index 9d5383343..cc3f64a78 100644 --- a/libretroshare/src/serialiser/rsgxsreputationitems.h +++ b/libretroshare/src/serialiser/rsgxsreputationitems.h @@ -34,6 +34,8 @@ #include "retroshare/rsgxsifacetypes.h" #include "retroshare/rsreputations.h" +#include "serialization/rsserializer.h" + #define RS_PKT_SUBTYPE_GXS_REPUTATION_CONFIG_ITEM 0x01 #define RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM_deprecated2 0x02 #define RS_PKT_SUBTYPE_GXS_REPUTATION_UPDATE_ITEM 0x03 @@ -53,15 +55,7 @@ class RsReputationItem: public RsItem } virtual ~RsReputationItem() {} - - virtual bool serialise(void *data,uint32_t& size) const = 0 ; - virtual uint32_t serial_size() const = 0 ; - virtual void clear() = 0 ; - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0; - - protected: - bool serialise_header(void *data, uint32_t& pktsize, uint32_t& tlvsize, uint32_t& offset) const; }; class RsGxsReputationConfigItem: public RsReputationItem @@ -71,16 +65,15 @@ public: virtual ~RsGxsReputationConfigItem() {} virtual void clear() {} - std::ostream &print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; - + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; + RsPeerId mPeerId; uint32_t mLatestUpdate; // timestamp they returned. uint32_t mLastQuery; // when we sent out. }; +#ifdef TO_REMOVE // This class should disappear. Deprecated since Jan 7, 2017. The class definition is actually not needed, // that is why it's commented out. Kept here in order to explains how the deserialisation works. // @@ -91,10 +84,8 @@ public: virtual ~RsGxsReputationSetItem_deprecated3() {} virtual void clear() {} - std::ostream &print(std::ostream &out, uint16_t /*indent*/ = 0) { return out;} - virtual bool serialise(void */*data*/,uint32_t& /*size*/) const { return false ;} - virtual uint32_t serial_size() const { return 0;} + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; RsGxsId mGxsId; uint32_t mOwnOpinion; @@ -103,6 +94,8 @@ public: RsPgpId mOwnerNodeId; std::map mOpinions; // RsPeerId -> Opinion. }; +#endif + class RsGxsReputationSetItem: public RsReputationItem { public: @@ -116,10 +109,8 @@ public: virtual ~RsGxsReputationSetItem() {} virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; RsGxsId mGxsId; uint32_t mOwnOpinion; @@ -136,10 +127,8 @@ public: virtual ~RsGxsReputationBannedNodeSetItem() {} virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; RsPgpId mPgpId ; uint32_t mLastActivityTS ; @@ -153,12 +142,10 @@ public: virtual ~RsGxsReputationUpdateItem() {} virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; - uint32_t mLatestUpdate; + uint32_t mLatestUpdate; std::map mOpinions; // GxsId -> Opinion. }; @@ -169,40 +156,20 @@ public: virtual ~RsGxsReputationRequestItem() {} virtual void clear() {} - std::ostream &print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; uint32_t mLastUpdate; }; -class RsGxsReputationSerialiser: public RsSerialType +class RsGxsReputationSerialiser: public RsSerializer { public: - RsGxsReputationSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_REPUTATION){} - + RsGxsReputationSerialiser() :RsSerializer(RS_SERVICE_GXS_TYPE_REPUTATION){} virtual ~RsGxsReputationSerialiser(){} - virtual uint32_t size(RsItem *item) - { - return dynamic_cast(item)->serial_size() ; - } - virtual bool serialise (RsItem *item, void *data, uint32_t *size) - { - return dynamic_cast(item)->serialise(data,*size) ; - } - virtual RsItem * deserialise(void *data, uint32_t *size); - -private: - static RsGxsReputationConfigItem *deserialiseReputationConfigItem (void *data, uint32_t size); - static RsGxsReputationSetItem *deserialiseReputationSetItem (void *data, uint32_t size); - static RsGxsReputationSetItem *deserialiseReputationSetItem_deprecated (void *data, uint32_t size); - static RsGxsReputationSetItem_deprecated3 *deserialiseReputationSetItem_deprecated3 (void *data, uint32_t size); - static RsGxsReputationUpdateItem *deserialiseReputationUpdateItem (void *data, uint32_t size); - static RsGxsReputationRequestItem *deserialiseReputationRequestItem (void *data, uint32_t size); - static RsGxsReputationBannedNodeSetItem *deserialiseReputationBannedNodeSetItem (void *data, uint32_t size); + virtual RsItem *create_item(uint16_t service,uint8_t item_type) const; }; /**************************************************************************/ diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 403219ecb..1899a26fe 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -85,6 +85,77 @@ class RsTypeSerializer throw std::runtime_error("Unknown serial job") ; } } + //=================================================================================================// + // std::map // + //=================================================================================================// + + template + static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,std::map& v,const std::string& member_name) + { + switch(j) + { + case RsItem::SIZE_ESTIMATE: + { + ctx.mOffset += 4 ; + for(typename std::map::iterator it(v.begin());it!=v.end();++it) + { + ctx.mOffset += serial_size(it->first) ; + ctx.mOffset += serial_size(it->second) ; + } + } + break ; + + case RsItem::DESERIALIZE: + { + uint32_t n=0 ; + ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; + + for(uint32_t i=0;i(ctx.mData,ctx.mSize,ctx.mOffset,n) ; + + for(typename std::map::iterator it(v.begin());it!=v.end();++it) + { + ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,it->first) ; + ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,it->second) ; + } + } + break ; + + case RsItem::PRINT: + { + if(v.empty()) + std::cerr << " Empty map"<< std::endl; + else + std::cerr << " std::map of " << v.size() << " elements:" << std::endl; + + for(typename std::map::iterator it(v.begin());it!=v.end();++it) + { + std::cerr << " " ; + + print_data("first",it->first) ; + print_data("second",it->second) ; + } + } + break; + default: + break; + } + } //=================================================================================================// // std::vector // diff --git a/libretroshare/src/services/p3gxsreputation.cc b/libretroshare/src/services/p3gxsreputation.cc index 45fd95898..cf956c0d8 100644 --- a/libretroshare/src/services/p3gxsreputation.cc +++ b/libretroshare/src/services/p3gxsreputation.cc @@ -1210,6 +1210,7 @@ bool p3GxsReputation::loadList(std::list& loadList) if (set) loadReputationSet(set, peerSet); +#ifdef TO_REMOVE RsGxsReputationSetItem_deprecated3 *set2 = dynamic_cast(*it); if(set2) @@ -1217,6 +1218,7 @@ bool p3GxsReputation::loadList(std::list& loadList) std::cerr << "(II) reading and converting old format ReputationSetItem." << std::endl; loadReputationSet_deprecated3(set2, peerSet); } +#endif RsGxsReputationBannedNodeSetItem *itm2 = dynamic_cast(*it) ; @@ -1274,6 +1276,7 @@ bool p3GxsReputation::loadList(std::list& loadList) loadList.clear() ; return true; } +#ifdef TO_REMOVE bool p3GxsReputation::loadReputationSet_deprecated3(RsGxsReputationSetItem_deprecated3 *item, const std::set &peerSet) { { @@ -1324,7 +1327,7 @@ bool p3GxsReputation::loadReputationSet_deprecated3(RsGxsReputationSetItem_depre #endif return true; } - +#endif bool p3GxsReputation::loadReputationSet(RsGxsReputationSetItem *item, const std::set &peerSet) { diff --git a/libretroshare/src/services/p3gxsreputation.h b/libretroshare/src/services/p3gxsreputation.h index baabdaa43..fdfd8ac54 100644 --- a/libretroshare/src/services/p3gxsreputation.h +++ b/libretroshare/src/services/p3gxsreputation.h @@ -156,7 +156,9 @@ private: // internal update of data. Takes care of cleaning empty boxes. void locked_updateOpinion(const RsPeerId &from, const RsGxsId &about, RsReputations::Opinion op); bool loadReputationSet(RsGxsReputationSetItem *item, const std::set &peerSet); +#ifdef TO_REMOVE bool loadReputationSet_deprecated3(RsGxsReputationSetItem_deprecated3 *item, const std::set &peerSet); +#endif int sendPackets(); void cleanup(); void sendReputationRequests(); From bef6db4b4362d49f38893c522cc72b7bb9b6bfa5 Mon Sep 17 00:00:00 2001 From: csoler Date: Sat, 22 Apr 2017 21:32:57 +0200 Subject: [PATCH 29/94] moved files --- libretroshare/src/{serialiser => rsitems}/rsgxsreputationitems.cc | 0 libretroshare/src/{serialiser => rsitems}/rsgxsreputationitems.h | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsgxsreputationitems.cc (100%) rename libretroshare/src/{serialiser => rsitems}/rsgxsreputationitems.h (100%) diff --git a/libretroshare/src/serialiser/rsgxsreputationitems.cc b/libretroshare/src/rsitems/rsgxsreputationitems.cc similarity index 100% rename from libretroshare/src/serialiser/rsgxsreputationitems.cc rename to libretroshare/src/rsitems/rsgxsreputationitems.cc diff --git a/libretroshare/src/serialiser/rsgxsreputationitems.h b/libretroshare/src/rsitems/rsgxsreputationitems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxsreputationitems.h rename to libretroshare/src/rsitems/rsgxsreputationitems.h From 2e7127077dab71675431e9826e494cff1cfc396d Mon Sep 17 00:00:00 2001 From: csoler Date: Sat, 22 Apr 2017 21:36:39 +0200 Subject: [PATCH 30/94] fixed previous file move --- libretroshare/src/libretroshare.pro | 4 ++-- libretroshare/src/rsitems/rsgxsreputationitems.cc | 2 +- libretroshare/src/services/p3gxsreputation.cc | 2 +- libretroshare/src/services/p3gxsreputation.h | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 2d7a966e9..16aba6778 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -784,12 +784,12 @@ HEADERS += retroshare/rsidentity.h \ services/p3idservice.h \ serialiser/rsgxsiditems.h \ services/p3gxsreputation.h \ - serialiser/rsgxsreputationitems.h \ + rsitems/rsgxsreputationitems.h \ SOURCES += services/p3idservice.cc \ serialiser/rsgxsiditems.cc \ services/p3gxsreputation.cc \ - serialiser/rsgxsreputationitems.cc \ + rsitems/rsgxsreputationitems.cc \ # GxsCircles Service HEADERS += services/p3gxscircles.h \ diff --git a/libretroshare/src/rsitems/rsgxsreputationitems.cc b/libretroshare/src/rsitems/rsgxsreputationitems.cc index e5240d91d..11e267654 100644 --- a/libretroshare/src/rsitems/rsgxsreputationitems.cc +++ b/libretroshare/src/rsitems/rsgxsreputationitems.cc @@ -26,7 +26,7 @@ #include #include #include "serialiser/rsbaseserial.h" -#include "serialiser/rsgxsreputationitems.h" +#include "rsitems/rsgxsreputationitems.h" #include "serialization/rstypeserializer.h" diff --git a/libretroshare/src/services/p3gxsreputation.cc b/libretroshare/src/services/p3gxsreputation.cc index cf956c0d8..609382444 100644 --- a/libretroshare/src/services/p3gxsreputation.cc +++ b/libretroshare/src/services/p3gxsreputation.cc @@ -29,7 +29,7 @@ #include "retroshare/rspeers.h" #include "services/p3gxsreputation.h" -#include "serialiser/rsgxsreputationitems.h" +#include "rsitems/rsgxsreputationitems.h" #include "serialiser/rsconfigitems.h" #include diff --git a/libretroshare/src/services/p3gxsreputation.h b/libretroshare/src/services/p3gxsreputation.h index fdfd8ac54..06ff7415b 100644 --- a/libretroshare/src/services/p3gxsreputation.h +++ b/libretroshare/src/services/p3gxsreputation.h @@ -36,7 +36,7 @@ static const uint32_t REPUTATION_IDENTITY_FLAG_UP_TO_DATE = 0x0100; // This static const uint32_t REPUTATION_IDENTITY_FLAG_PGP_LINKED = 0x0001; static const uint32_t REPUTATION_IDENTITY_FLAG_PGP_KNOWN = 0x0002; -#include "serialiser/rsgxsreputationitems.h" +#include "rsitems/rsgxsreputationitems.h" #include "retroshare/rsidentity.h" #include "retroshare/rsreputations.h" From 9d9ff567bbe4611b36bc0bd46537c9a70b5e2303 Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 23 Apr 2017 19:02:12 +0200 Subject: [PATCH 31/94] switched discovery2items to new serialization --- .../src/serialiser/rsdiscovery2items.cc | 179 ++++++++++++------ .../src/serialiser/rsdiscovery2items.h | 84 +++----- 2 files changed, 149 insertions(+), 114 deletions(-) diff --git a/libretroshare/src/serialiser/rsdiscovery2items.cc b/libretroshare/src/serialiser/rsdiscovery2items.cc index 90b4313b3..8cd94f9d9 100644 --- a/libretroshare/src/serialiser/rsdiscovery2items.cc +++ b/libretroshare/src/serialiser/rsdiscovery2items.cc @@ -27,6 +27,8 @@ #include "serialiser/rsdiscovery2items.h" #include "serialiser/rsbaseserial.h" +#include "serialization/rstypeserializer.h" + #if 0 #include "rsitems/rsserviceids.h" @@ -44,6 +46,121 @@ #include +RsItem *RsDiscSerialiser::create_item(uint16_t service,uint8_t item_subtype) const +{ + if(service != RS_SERVICE_TYPE_DISC) + return NULL ; + + switch(item_subtype) + { + case RS_PKT_SUBTYPE_DISC_PGP_LIST : return new RsDiscPgpListItem() ; //= 0x01; + case RS_PKT_SUBTYPE_DISC_PGP_CERT : return new RsDiscPgpCertItem() ; //= 0x02; + case RS_PKT_SUBTYPE_DISC_CONTACT_deprecated : return NULL ; //= 0x03; +#if 0 + case RS_PKT_SUBTYPE_DISC_SERVICES : return new RsDiscServicesItem(); //= 0x04; +#endif + case RS_PKT_SUBTYPE_DISC_CONTACT : return new RsDiscContactItem(); //= 0x05; + default: + return NULL ; + } +} + +/*************************************************************************/ + +void RsDiscPgpListItem::clear() +{ + mode = DISC_PGP_LIST_MODE_NONE; + pgpIdSet.TlvClear(); +} + +void RsDiscPgpListItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mode,"mode") ; + RsTypeSerializer::serial_process(j,ctx,pgpIdSet,"pgpIdSet") ; +} + +void RsDiscPgpCertItem::clear() +{ + pgpId.clear(); + pgpCert.clear(); +} + + +void RsDiscPgpCertItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,pgpId,"pgpId") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_PGPCERT,pgpCert,"pgpCert") ; +} + +void RsDiscContactItem::clear() +{ + pgpId.clear(); + sslId.clear(); + + location.clear(); + version.clear(); + + netMode = 0; + vs_disc = 0; + vs_dht = 0; + lastContact = 0; + + isHidden = false; + hiddenAddr.clear(); + hiddenPort = 0; + + localAddrV4.TlvClear(); + extAddrV4.TlvClear(); + localAddrV6.TlvClear(); + extAddrV6.TlvClear(); + + + dyndns.clear(); + + localAddrList.TlvClear(); + extAddrList.TlvClear(); +} + +void RsDiscContactItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,pgpId,"pgpId"); + RsTypeSerializer::serial_process (j,ctx,sslId,"sslId"); + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_LOCATION,location,"location"); + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_VERSION,version,"version"); + RsTypeSerializer::serial_process(j,ctx,netMode,"netMode"); + RsTypeSerializer::serial_process(j,ctx,vs_disc,"vs_disc"); + RsTypeSerializer::serial_process(j,ctx,vs_dht,"vs_dht"); + RsTypeSerializer::serial_process(j,ctx,lastContact,"lastContact"); + + // This is a hack. Normally we should have to different item types, in order to avoid this nonesense. + + if( (j == RsItem::DESERIALIZE && GetTlvType( &(((uint8_t *) ctx.mData)[ctx.mOffset]) )==TLV_TYPE_STR_DOMADDR) || isHidden) + { + isHidden = true ; + + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_DOMADDR,hiddenAddr,"hiddenAddr"); + RsTypeSerializer::serial_process(j,ctx,hiddenPort,"hiddenPort"); + } + else + { + isHidden = false ; + + RsTypeSerializer::serial_process(j,ctx,localAddrV4,"localAddrV4"); + RsTypeSerializer::serial_process(j,ctx, extAddrV4,"extAddrV4"); + RsTypeSerializer::serial_process(j,ctx,localAddrV6,"localAddrV6"); + RsTypeSerializer::serial_process(j,ctx, extAddrV6,"extAddrV6"); + RsTypeSerializer::serial_process(j,ctx,currentConnectAddress,"currentConnectAddress"); + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_DYNDNS,dyndns,"dyndns"); + RsTypeSerializer::serial_process (j,ctx,localAddrList,"localAddrList"); + RsTypeSerializer::serial_process (j,ctx, extAddrList,"extAddrList"); + } +} + +/*************************************************************************/ + + + +#ifdef TO_REMOVE /*************************************************************************/ uint32_t RsDiscSerialiser::size(RsItem *i) @@ -138,20 +255,6 @@ RsItem *RsDiscSerialiser::deserialise(void *data, uint32_t *pktsize) } return NULL; } - -/*************************************************************************/ - -RsDiscPgpListItem::~RsDiscPgpListItem() -{ - return; -} - -void RsDiscPgpListItem::clear() -{ - mode = DISC_PGP_LIST_MODE_NONE; - pgpIdSet.TlvClear(); -} - std::ostream &RsDiscPgpListItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsDiscPgpListItem", indent); @@ -173,7 +276,6 @@ uint32_t RsDiscSerialiser::sizePgpList(RsDiscPgpListItem *item) s += item->pgpIdSet.TlvSize(); return s; } - /* serialise the data to the buffer */ bool RsDiscSerialiser::serialisePgpList(RsDiscPgpListItem *item, void *data, uint32_t *pktsize) { @@ -273,6 +375,7 @@ RsDiscPgpListItem *RsDiscSerialiser::deserialisePgpList(void *data, uint32_t *pk return item; } +#endif /*************************************************************************/ /*************************************************************************/ @@ -410,22 +513,11 @@ RsDiscServicesItem *RsDiscSerialiser::deserialiseServices(void *data, uint32_t * return item; } -#endif - - -/*************************************************************************/ - RsDiscPgpCertItem::~RsDiscPgpCertItem() { return; } -void RsDiscPgpCertItem::clear() -{ - pgpId.clear(); - pgpCert.clear(); -} - std::ostream &RsDiscPgpCertItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsDiscPgpCertItem", indent); @@ -448,7 +540,6 @@ uint32_t RsDiscSerialiser::sizePgpCert(RsDiscPgpCertItem *item) s += GetTlvStringSize(item->pgpCert); return s; } - /* serialise the data to the buffer */ bool RsDiscSerialiser::serialisePgpCert(RsDiscPgpCertItem *item, void *data, uint32_t *pktsize) { @@ -557,35 +648,6 @@ RsDiscContactItem::~RsDiscContactItem() return; } -void RsDiscContactItem::clear() -{ - pgpId.clear(); - sslId.clear(); - - location.clear(); - version.clear(); - - netMode = 0; - vs_disc = 0; - vs_dht = 0; - lastContact = 0; - - isHidden = false; - hiddenAddr.clear(); - hiddenPort = 0; - - localAddrV4.TlvClear(); - extAddrV4.TlvClear(); - localAddrV6.TlvClear(); - extAddrV6.TlvClear(); - - - dyndns.clear(); - - localAddrList.TlvClear(); - extAddrList.TlvClear(); -} - std::ostream &RsDiscContactItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsDiscContact", indent); @@ -657,7 +719,6 @@ std::ostream &RsDiscContactItem::print(std::ostream &out, uint16_t indent) return out; } - uint32_t RsDiscSerialiser::sizeContact(RsDiscContactItem *item) { uint32_t s = 8; /* header */ @@ -893,6 +954,4 @@ RsDiscContactItem *RsDiscSerialiser::deserialiseContact(void *data, uint32_t *pk return item; } - -/*************************************************************************/ - +#endif diff --git a/libretroshare/src/serialiser/rsdiscovery2items.h b/libretroshare/src/serialiser/rsdiscovery2items.h index 26bbf1f22..fc1a944cb 100644 --- a/libretroshare/src/serialiser/rsdiscovery2items.h +++ b/libretroshare/src/serialiser/rsdiscovery2items.h @@ -33,6 +33,8 @@ #include "serialiser/rstlvaddrs.h" #include "rsitems/rsserviceids.h" +#include "serialization/rsserializer.h" + const uint8_t RS_PKT_SUBTYPE_DISC_PGP_LIST = 0x01; const uint8_t RS_PKT_SUBTYPE_DISC_PGP_CERT = 0x02; const uint8_t RS_PKT_SUBTYPE_DISC_CONTACT_deprecated = 0x03; @@ -52,18 +54,18 @@ class RsDiscItem: public RsItem class RsDiscPgpListItem: public RsDiscItem { - public: +public: - RsDiscPgpListItem() - :RsDiscItem(RS_PKT_SUBTYPE_DISC_PGP_LIST) - { + RsDiscPgpListItem() + :RsDiscItem(RS_PKT_SUBTYPE_DISC_PGP_LIST) + { setPriorityLevel(QOS_PRIORITY_RS_DISC_PGP_LIST); } -virtual ~RsDiscPgpListItem(); + virtual ~RsDiscPgpListItem(){} -virtual void clear(); -virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void clear(); + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); uint32_t mode; RsTlvPgpIdSet pgpIdSet; @@ -73,18 +75,18 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); class RsDiscPgpCertItem: public RsDiscItem { - public: +public: - RsDiscPgpCertItem() - :RsDiscItem(RS_PKT_SUBTYPE_DISC_PGP_CERT) - { + RsDiscPgpCertItem() + :RsDiscItem(RS_PKT_SUBTYPE_DISC_PGP_CERT) + { setPriorityLevel(QOS_PRIORITY_RS_DISC_PGP_CERT); } -virtual ~RsDiscPgpCertItem(); + virtual ~RsDiscPgpCertItem(){} -virtual void clear(); -virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void clear(); + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); RsPgpId pgpId; std::string pgpCert; @@ -93,30 +95,30 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); class RsDiscContactItem: public RsDiscItem { - public: +public: RsDiscContactItem() - :RsDiscItem(RS_PKT_SUBTYPE_DISC_CONTACT) - { - setPriorityLevel(QOS_PRIORITY_RS_DISC_CONTACT); + :RsDiscItem(RS_PKT_SUBTYPE_DISC_CONTACT) + { + setPriorityLevel(QOS_PRIORITY_RS_DISC_CONTACT); } -virtual ~RsDiscContactItem(); + virtual ~RsDiscContactItem() {} -virtual void clear(); -virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void clear(); + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); RsPgpId pgpId; RsPeerId sslId; // COMMON - std::string location; + std::string location; std::string version; uint32_t netMode; /* Mandatory */ uint16_t vs_disc; /* Mandatory */ uint16_t vs_dht; /* Mandatory */ - uint32_t lastContact; + uint32_t lastContact; bool isHidden; /* not serialised */ @@ -126,7 +128,7 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); // STANDARD. - RsTlvIpAddress currentConnectAddress ; // used to check! + RsTlvIpAddress currentConnectAddress ; // used to check! RsTlvIpAddress localAddrV4; /* Mandatory */ RsTlvIpAddress extAddrV4; /* Mandatory */ @@ -164,40 +166,14 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); #endif -class RsDiscSerialiser: public RsSerialType +class RsDiscSerialiser: public RsSerializer { public: - RsDiscSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISC) - { return; } + RsDiscSerialiser() :RsSerializer(RS_SERVICE_TYPE_DISC) {} -virtual ~RsDiscSerialiser() { return; } - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - -virtual uint32_t sizePgpList(RsDiscPgpListItem *); -virtual bool serialisePgpList(RsDiscPgpListItem *item, void *data, uint32_t *size); -virtual RsDiscPgpListItem *deserialisePgpList(void *data, uint32_t *size); - -virtual uint32_t sizePgpCert(RsDiscPgpCertItem *); -virtual bool serialisePgpCert(RsDiscPgpCertItem *item, void *data, uint32_t *size); -virtual RsDiscPgpCertItem *deserialisePgpCert(void *data, uint32_t *size); - -virtual uint32_t sizeContact(RsDiscContactItem *); -virtual bool serialiseContact(RsDiscContactItem *item, void *data, uint32_t *size); -virtual RsDiscContactItem *deserialiseContact(void *data, uint32_t *size); - -#if 0 -virtual uint32_t sizeServices(RsDiscServicesItem *); -virtual bool serialiseServices(RsDiscServicesItem *item, void *data, uint32_t *size); -virtual RsDiscServicesItem *deserialiseServices(void *data, uint32_t *size); - -#endif + virtual ~RsDiscSerialiser() {} + RsItem *create_item(uint16_t service,uint8_t item_subtype) const ; }; From 63b4b3a1f785a119b717a5c50280053967407141 Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 23 Apr 2017 19:07:26 +0200 Subject: [PATCH 32/94] moved discovery2 items to rsitems/ --- libretroshare/src/libretroshare.pro | 4 ++-- .../src/{serialiser => rsitems}/rsdiscovery2items.cc | 2 +- libretroshare/src/{serialiser => rsitems}/rsdiscovery2items.h | 0 libretroshare/src/services/p3discovery2.h | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsdiscovery2items.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rsdiscovery2items.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 16aba6778..15ab467b3 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -481,7 +481,7 @@ HEADERS += rsitems/itempriorities.h \ serialiser/rstlvbanlist.h \ rsitems/rsbanlistitems.h \ rsitems/rsbwctrlitems.h \ - serialiser/rsdiscovery2items.h \ + rsitems/rsdiscovery2items.h \ serialiser/rsheartbeatitems.h \ serialiser/rsrttitems.h \ serialiser/rsgxsrecognitems.h \ @@ -629,7 +629,7 @@ SOURCES += serialiser/rsbaseserial.cc \ serialiser/rstlvbanlist.cc \ rsitems/rsbanlistitems.cc \ rsitems/rsbwctrlitems.cc \ - serialiser/rsdiscovery2items.cc \ + rsitems/rsdiscovery2items.cc \ serialiser/rsheartbeatitems.cc \ serialiser/rsrttitems.cc \ serialiser/rsgxsrecognitems.cc \ diff --git a/libretroshare/src/serialiser/rsdiscovery2items.cc b/libretroshare/src/rsitems/rsdiscovery2items.cc similarity index 99% rename from libretroshare/src/serialiser/rsdiscovery2items.cc rename to libretroshare/src/rsitems/rsdiscovery2items.cc index 8cd94f9d9..e1e939ffa 100644 --- a/libretroshare/src/serialiser/rsdiscovery2items.cc +++ b/libretroshare/src/rsitems/rsdiscovery2items.cc @@ -24,7 +24,7 @@ * */ -#include "serialiser/rsdiscovery2items.h" +#include "rsitems/rsdiscovery2items.h" #include "serialiser/rsbaseserial.h" #include "serialization/rstypeserializer.h" diff --git a/libretroshare/src/serialiser/rsdiscovery2items.h b/libretroshare/src/rsitems/rsdiscovery2items.h similarity index 100% rename from libretroshare/src/serialiser/rsdiscovery2items.h rename to libretroshare/src/rsitems/rsdiscovery2items.h diff --git a/libretroshare/src/services/p3discovery2.h b/libretroshare/src/services/p3discovery2.h index 2d063ee77..79ac13135 100644 --- a/libretroshare/src/services/p3discovery2.h +++ b/libretroshare/src/services/p3discovery2.h @@ -35,7 +35,7 @@ #include "pqi/p3netmgr.h" #include "pqi/pqiservicemonitor.h" -#include "serialiser/rsdiscovery2items.h" +#include "rsitems/rsdiscovery2items.h" #include "services/p3service.h" #include "pqi/authgpg.h" From 31c07f4dfd6db51fec429b332be5e87fbb11f219 Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 23 Apr 2017 22:40:26 +0200 Subject: [PATCH 33/94] converted RsMsgItems to new serialization. Added format and flag members to RsSerialiser and used the later to handle signature and config serialization techniques --- libretroshare/src/chat/distributedchat.cc | 10 +- libretroshare/src/chat/rschatitems.cc | 59 +------ libretroshare/src/chat/rschatitems.h | 11 +- libretroshare/src/retroshare/rsflags.h | 9 +- libretroshare/src/serialiser/rsmsgitems.cc | 162 ++++++++++++++---- libretroshare/src/serialiser/rsmsgitems.h | 82 ++------- .../src/serialization/rsserializer.cc | 12 +- .../src/serialization/rsserializer.h | 21 ++- .../src/serialization/rstypeserializer.h | 11 +- libretroshare/src/services/p3msgservice.cc | 8 +- 10 files changed, 202 insertions(+), 183 deletions(-) diff --git a/libretroshare/src/chat/distributedchat.cc b/libretroshare/src/chat/distributedchat.cc index c83ddde8e..f79b71a18 100644 --- a/libretroshare/src/chat/distributedchat.cc +++ b/libretroshare/src/chat/distributedchat.cc @@ -222,7 +222,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const mGixs->requestKey(obj->signature.keyId,peer_list,RsIdentityUsage(RS_SERVICE_TYPE_CHAT,RsIdentityUsage::CHAT_LOBBY_MSG_VALIDATION,RsGxsGroupId(),RsGxsMessageId(),obj->lobby_id)); - uint32_t size = obj->serial_size_for_signature() ; + uint32_t size = RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).size((RsItem*)obj) ; RsTemporaryMemory memory(size) ; #ifdef DEBUG_CHAT_LOBBIES @@ -230,7 +230,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const std::cerr << " signature id: " << obj->signature.keyId << std::endl; #endif - if(!obj->serialize_for_signature(memory,size)) + if(!RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise((RsItem*)obj,memory,&size)) { std::cerr << " (EE) Cannot serialise message item. " << std::endl; return false ; @@ -239,7 +239,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const uint32_t error_status ; RsIdentityUsage use_info(RS_SERVICE_TYPE_CHAT,RsIdentityUsage::CHAT_LOBBY_MSG_VALIDATION,RsGxsGroupId(),RsGxsMessageId(),obj->lobby_id) ; - if(!mGixs->validateData(memory,obj->serial_size_for_signature(),obj->signature,false,use_info,error_status)) + if(!mGixs->validateData(memory,size,obj->signature,false,use_info,error_status)) { bool res = false ; @@ -970,10 +970,10 @@ bool DistributedChatService::locked_initLobbyBouncableObject(const ChatLobbyId& // now sign the object, if the lobby expects it - uint32_t size = item.serial_size_for_signature() ; + uint32_t size = RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).size((RsItem*)&item) ; RsTemporaryMemory memory(size) ; - if(!item.serialize_for_signature(memory,size)) + if(!RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise((RsItem*)&item,memory,&size)) { std::cerr << "(EE) Cannot sign message item. " << std::endl; return false ; diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 23f4aab25..75d90e0a4 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -80,13 +80,13 @@ RsChatAvatarItem::~RsChatAvatarItem() } } -void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, SerializeContext& ctx, bool include_signature) +void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_NAME,nick,"nick") ; - if(include_signature) + if(!(ctx.mFlags & RsSerializer::SERIALIZATION_FLAG_SIGNATURE)) RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; } @@ -94,13 +94,7 @@ void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& { RsChatMsgItem::serial_process(j,ctx) ; RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; - RsChatLobbyBouncingObject::serial_process(j,ctx,true) ; -} -void RsChatLobbyMsgItem::serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) -{ - RsChatMsgItem::serial_process(j,ctx) ; - RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; - RsChatLobbyBouncingObject::serial_process(j,ctx,false) ; + RsChatLobbyBouncingObject::serial_process(j,ctx) ; } void RsChatLobbyListRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) @@ -129,15 +123,7 @@ void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContex RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,string1,"string1") ; RsTypeSerializer::serial_process(j,ctx,sendTime ,"sendTime") ; - RsChatLobbyBouncingObject::serial_process(j,ctx,true) ; -} -void RsChatLobbyEventItem::serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) -{ - RsTypeSerializer::serial_process(j,ctx,event_type,"event_type") ; - RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,string1,"string1") ; - RsTypeSerializer::serial_process(j,ctx,sendTime ,"sendTime") ; - - RsChatLobbyBouncingObject::serial_process(j,ctx,false) ; + RsChatLobbyBouncingObject::serial_process(j,ctx) ; } void RsChatLobbyUnsubscribeItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) { @@ -209,41 +195,4 @@ void RsPrivateChatMsgConfigItem::get(RsChatMsgItem *ci) ci->recvTime = recvTime; } -uint32_t RsChatLobbyBouncingObject::serial_size_for_signature() const -{ - SerializeContext ctx(NULL,0); - - ctx.mOffset = 8; - - const_cast(this)->serial_process_for_signature(RsItem::SIZE_ESTIMATE,ctx) ; - - return ctx.mOffset ; -} - -bool RsChatLobbyBouncingObject::serialize_for_signature(uint8_t *data,uint32_t size) const -{ - SerializeContext ctx(data,0); - - uint32_t tlvsize = serial_size_for_signature() ; - - if(tlvsize > size) - throw std::runtime_error("Cannot serialise: not enough room.") ; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; - return false ; - } - ctx.mOffset = 8; - ctx.mSize = tlvsize; - - const_cast(this)->serial_process_for_signature(RsItem::SERIALIZE,ctx) ; - - if(ctx.mSize != ctx.mOffset) - { - std::cerr << "RsChatSerializer::serialise_item(): ERROR. offset does not match expected size!" << std::endl; - return false ; - } - return true ; -} diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 456ffe5b6..b357f0873 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -137,16 +137,12 @@ public: virtual RsChatLobbyBouncingObject *duplicate() const = 0 ; - uint32_t serial_size_for_signature() const ; - bool serialize_for_signature(uint8_t *data,uint32_t size) const ; - protected: // The functions below handle the serialisation of data that is specific to the bouncing object level. // They are called by serial_size() and serialise() from children, but should not overload the serial_size() and // serialise() methods, otherwise the wrong method will be called when serialising from this top level class. - virtual void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,bool include_signature); - virtual void serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx)=0; + virtual void serial_process(RsItem::SerializeJob j, SerializeContext& ctx); virtual uint32_t PacketId() const= 0; }; @@ -160,7 +156,6 @@ public: virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyMsgItem(*this) ; } void serial_process(RsItem::SerializeJob j,SerializeContext& ctx) ; - void serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) ; // This one is new, and used to add/remove signature on demand ChatLobbyMsgId parent_msg_id ; // Used for threaded chat. @@ -177,7 +172,6 @@ public: virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyEventItem(*this) ; } // void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); - void serial_process_for_signature(RsItem::SerializeJob j,SerializeContext& ctx) ; // This one is new, and used to add/remove signature on demand // members. // @@ -330,7 +324,8 @@ class RsChatAvatarItem: public RsChatItem class RsChatSerialiser: public RsSerializer { public: - RsChatSerialiser() :RsSerializer(RS_SERVICE_TYPE_CHAT) {} + RsChatSerialiser(SerializationFlags flags = SERIALIZATION_FLAG_NONE) + :RsSerializer(RS_SERVICE_TYPE_CHAT,SerializeContext::FORMAT_BINARY,flags) {} virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) const ; }; diff --git a/libretroshare/src/retroshare/rsflags.h b/libretroshare/src/retroshare/rsflags.h index 500ed42d4..548b1641b 100644 --- a/libretroshare/src/retroshare/rsflags.h +++ b/libretroshare/src/retroshare/rsflags.h @@ -59,11 +59,12 @@ template class t_RsFlags32 uint32_t _bits ; }; -#define FLAGS_TAG_TRANSFER_REQS 0x4228af +#define FLAGS_TAG_TRANSFER_REQS 0x4228af #define FLAGS_TAG_FILE_STORAGE 0x184738 -#define FLAGS_TAG_FILE_SEARCH 0xf29ba5 +#define FLAGS_TAG_FILE_SEARCH 0xf29ba5 #define FLAGS_TAG_SERVICE_PERM 0x380912 #define FLAGS_TAG_SERVICE_CHAT 0x839042 +#define FLAGS_TAG_SERIALIZER 0xa0338d // Flags for requesting transfers, ask for turtle, cache, speed, etc. // @@ -85,3 +86,7 @@ typedef t_RsFlags32 ServicePermissionFlags ; // typedef t_RsFlags32 ChatLobbyFlags ; +// Flags for serializer +// +typedef t_RsFlags32 SerializationFlags ; + diff --git a/libretroshare/src/serialiser/rsmsgitems.cc b/libretroshare/src/serialiser/rsmsgitems.cc index 69c1028ee..9fc3d7e40 100644 --- a/libretroshare/src/serialiser/rsmsgitems.cc +++ b/libretroshare/src/serialiser/rsmsgitems.cc @@ -30,12 +30,35 @@ #include "serialiser/rsmsgitems.h" #include "serialiser/rstlvbase.h" +#include "serialization/rstypeserializer.h" + /*** #define RSSERIAL_DEBUG 1 ***/ #include + +RsItem *RsMsgSerialiser::create_item(uint16_t service,uint8_t type) const +{ + if(service != RS_SERVICE_TYPE_MSG) + return NULL ; + + switch(type) + { + case RS_PKT_SUBTYPE_DEFAULT : return new RsMsgItem() ; //= 0x01; + case RS_PKT_SUBTYPE_MSG_TAG_TYPE : return new RsMsgTagType() ; //= 0x03; + case RS_PKT_SUBTYPE_MSG_TAGS : return new RsMsgTags() ; //= 0x04; + case RS_PKT_SUBTYPE_MSG_SRC_TAG : return new RsMsgSrcId(); //= 0x05; + case RS_PKT_SUBTYPE_MSG_PARENT_TAG : return new RsMsgParentId() ; //= 0x06; + case RS_PKT_SUBTYPE_MSG_INVITE : return new RsPublicMsgInviteConfigItem(); //= 0x07; + case RS_PKT_SUBTYPE_MSG_GROUTER_MAP : return new RsMsgGRouterMap(); //= 0x08; + case RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP : return new RsMsgDistantMessagesHashMap();//= 0x09; + default: + return NULL ; + } +} + void RsMsgItem::clear() { msgId = 0; @@ -56,6 +79,107 @@ void RsMsgItem::clear() attachment.TlvClear(); } +void RsPublicMsgInviteConfigItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_SHA1,hash,"hash") ; + RsTypeSerializer::serial_process(j,ctx,(uint32_t&)time_stamp,"time_stamp") ; +} +void RsMsgTagType::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_NAME,text,"text") ; + RsTypeSerializer::serial_process(j,ctx,rgb_color,"rgb_color") ; + RsTypeSerializer::serial_process(j,ctx,tagId,"tagId") ; +} + +void RsMsgTags::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,msgId,"msgId") ; + +#warning this is not the correct way to serialise here. We should directly call serial_process >() but for backward compatibility, we cannot + + if(j == RsItem::DESERIALIZE) + while(ctx.mOffset < ctx.mSize) + { + uint32_t n ; + RsTypeSerializer::serial_process(j,ctx,n,"tagIds element") ; + tagIds.push_back(n) ; + } + else + for(std::list::iterator it(tagIds.begin());it!=tagIds.end();++it) + RsTypeSerializer::serial_process(j,ctx,*it,"tagIds element") ; +} + +void RsMsgSrcId::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,msgId,"msgId") ; + RsTypeSerializer::serial_process (j,ctx,srcId,"srcId") ; +} + +void RsMsgGRouterMap::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,ongoing_msgs,"ongoing_msgs") ; +} + +void RsMsgGRouterMap::clear() +{ + ongoing_msgs.clear() ; + + return; +} + +void RsMsgDistantMessagesHashMap::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,hash_map,"hash_map") ; +} + +void RsMsgParentId::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,msgId,"msgId") ; + RsTypeSerializer::serial_process(j,ctx,msgParentId,"msgParentId") ; +} + +void RsMsgItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,msgFlags,"msgFlags"); + RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime"); + RsTypeSerializer::serial_process(j,ctx,recvTime,"recvTime"); + + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_SUBJECT,subject,"subject"); + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_MSG,message,"message"); + + RsTypeSerializer::serial_process(j,ctx,rspeerid_msgto,"rspeerid_msgto"); + RsTypeSerializer::serial_process(j,ctx,rspeerid_msgcc,"rspeerid_msgcc"); + RsTypeSerializer::serial_process(j,ctx,rspeerid_msgbcc,"rspeerid_msgbcc"); + + RsTypeSerializer::serial_process(j,ctx,rsgxsid_msgto,"rsgxsid_msgto"); + RsTypeSerializer::serial_process(j,ctx,rsgxsid_msgcc,"rsgxsid_msgcc"); + RsTypeSerializer::serial_process(j,ctx,rsgxsid_msgbcc,"rsgxsid_msgbcc"); + + RsTypeSerializer::serial_process(j,ctx,attachment,"attachment"); + + if(ctx.mFlags & RsSerializer::SERIALIZATION_FLAG_CONFIG) + RsTypeSerializer::serial_process(j,ctx,msgId,"msgId"); +} + +void RsMsgTagType::clear() +{ + text.clear(); + tagId = 0; + rgb_color = 0; +} + +void RsPublicMsgInviteConfigItem::clear() +{ + hash.clear() ; + time_stamp = 0 ; +} +void RsMsgTags::clear() +{ + msgId = 0; + tagIds.clear(); +} + +#ifdef TO_REMOVE std::ostream &RsMsgItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsMsgItem", indent); @@ -100,19 +224,6 @@ std::ostream &RsMsgItem::print(std::ostream &out, uint16_t indent) printRsItemEnd(out, "RsMsgItem", indent); return out; } - -void RsMsgTagType::clear() -{ - text.clear(); - tagId = 0; - rgb_color = 0; -} - -void RsPublicMsgInviteConfigItem::clear() -{ - hash.clear() ; - time_stamp = 0 ; -} std::ostream& RsPublicMsgInviteConfigItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsPublicMsgInviteConfigItem", indent); @@ -128,12 +239,6 @@ std::ostream& RsPublicMsgInviteConfigItem::print(std::ostream &out, uint16_t ind return out; } -void RsMsgTags::clear() -{ - msgId = 0; - tagIds.clear(); -} - std::ostream& RsMsgTagType::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsMsgTagType", indent); @@ -346,7 +451,6 @@ uint32_t RsMsgTagType::serial_size(bool) return s; } - bool RsPublicMsgInviteConfigItem::serialise(void *data, uint32_t& pktsize,bool config) { uint32_t tlvsize = serial_size(config) ; @@ -382,8 +486,6 @@ bool RsPublicMsgInviteConfigItem::serialise(void *data, uint32_t& pktsize,bool c return ok; } - - bool RsMsgTagType::serialise(void *data, uint32_t& pktsize,bool config) { uint32_t tlvsize = serial_size( config) ; @@ -536,7 +638,6 @@ uint32_t RsMsgTags::serial_size(bool) return s; } - bool RsMsgTags::serialise(void *data, uint32_t& pktsize,bool config) { uint32_t tlvsize = serial_size( config) ; @@ -672,8 +773,6 @@ uint32_t RsMsgSrcId::serial_size(bool) return s; } - - bool RsMsgSrcId::serialise(void *data, uint32_t& pktsize,bool config) { uint32_t tlvsize = serial_size(config) ; @@ -777,14 +876,6 @@ std::ostream& RsMsgGRouterMap::print(std::ostream& out, uint16_t indent) return out; } - -void RsMsgGRouterMap::clear() -{ - ongoing_msgs.clear() ; - - return; -} - uint32_t RsMsgGRouterMap::serial_size(bool) { uint32_t s = 8; /* header */ @@ -933,7 +1024,6 @@ uint32_t RsMsgDistantMessagesHashMap::serial_size(bool) return s; } - bool RsMsgDistantMessagesHashMap::serialise(void *data, uint32_t& pktsize,bool config) { uint32_t tlvsize = serial_size(config) ; @@ -1073,7 +1163,6 @@ uint32_t RsMsgParentId::serial_size(bool) return s; } - bool RsMsgParentId::serialise(void *data, uint32_t& pktsize,bool config) { uint32_t tlvsize = serial_size( config) ; @@ -1198,3 +1287,6 @@ RsItem* RsMsgSerialiser::deserialise(void *data, uint32_t *pktsize) /*************************************************************************/ +#endif + + diff --git a/libretroshare/src/serialiser/rsmsgitems.h b/libretroshare/src/serialiser/rsmsgitems.h index 0d44aa501..5eb94e5b4 100644 --- a/libretroshare/src/serialiser/rsmsgitems.h +++ b/libretroshare/src/serialiser/rsmsgitems.h @@ -90,10 +90,6 @@ class RsMessageItem: public RsItem virtual ~RsMessageItem() {} virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0 ; - - virtual bool serialise(void *data,uint32_t& size,bool config) = 0 ; - virtual uint32_t serial_size(bool config) = 0 ; }; @@ -105,10 +101,7 @@ class RsMsgItem: public RsMessageItem virtual ~RsMsgItem() {} virtual void clear(); - virtual bool serialise(void *data,uint32_t& size,bool config) ; - virtual uint32_t serial_size(bool config) ; - - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); // ----------- Specific fields ------------- // @@ -137,10 +130,7 @@ class RsMsgTagType : public RsMessageItem public: RsMsgTagType() :RsMessageItem(RS_PKT_SUBTYPE_MSG_TAG_TYPE) {} - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size,bool config) ; - virtual uint32_t serial_size(bool config) ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); virtual ~RsMsgTagType() {} virtual void clear(); @@ -158,10 +148,7 @@ public: RsMsgTags() :RsMessageItem(RS_PKT_SUBTYPE_MSG_TAGS) {} - virtual bool serialise(void *data,uint32_t& size,bool config) ; - virtual uint32_t serial_size(bool config) ; - - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); virtual ~RsMsgTags() {} virtual void clear(); @@ -177,13 +164,10 @@ class RsMsgSrcId : public RsMessageItem public: RsMsgSrcId() : RsMessageItem(RS_PKT_SUBTYPE_MSG_SRC_TAG) {} - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size,bool config) ; - virtual uint32_t serial_size(bool config) ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); virtual ~RsMsgSrcId() {} - virtual void clear(); + virtual void clear(){} // ----------- Specific fields ------------- // // @@ -196,10 +180,7 @@ class RsPublicMsgInviteConfigItem : public RsMessageItem public: RsPublicMsgInviteConfigItem() : RsMessageItem(RS_PKT_SUBTYPE_MSG_INVITE) {} - virtual bool serialise(void *data,uint32_t& size,bool config) ; - virtual uint32_t serial_size(bool config) ; - - std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); virtual ~RsPublicMsgInviteConfigItem() {} virtual void clear(); @@ -215,10 +196,7 @@ class RsMsgGRouterMap : public RsMessageItem public: RsMsgGRouterMap() : RsMessageItem(RS_PKT_SUBTYPE_MSG_GROUTER_MAP) {} - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size,bool config) ; - virtual uint32_t serial_size(bool config) ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); virtual ~RsMsgGRouterMap() {} virtual void clear(); @@ -232,13 +210,10 @@ class RsMsgDistantMessagesHashMap : public RsMessageItem public: RsMsgDistantMessagesHashMap() : RsMessageItem(RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP) {} - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size,bool config) ; - virtual uint32_t serial_size(bool config) ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); virtual ~RsMsgDistantMessagesHashMap() {} - virtual void clear(); + virtual void clear() { hash_map.clear() ;} // ----------- Specific fields ------------- // // @@ -249,13 +224,10 @@ class RsMsgParentId : public RsMessageItem public: RsMsgParentId() : RsMessageItem(RS_PKT_SUBTYPE_MSG_PARENT_TAG) {} - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size,bool config) ; - virtual uint32_t serial_size(bool config) ; + virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); virtual ~RsMsgParentId() {} - virtual void clear(); + virtual void clear(){} // ----------- Specific fields ------------- // // @@ -263,39 +235,15 @@ class RsMsgParentId : public RsMessageItem uint32_t msgParentId; }; -class RsMsgSerialiser: public RsSerialType +class RsMsgSerialiser: public RsSerializer { public: - RsMsgSerialiser(bool bConfiguration = false) - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_MSG), m_bConfiguration (bConfiguration) {} - - RsMsgSerialiser(uint16_t type) - :RsSerialType(RS_PKT_VERSION_SERVICE, type), m_bConfiguration (false) {} + RsMsgSerialiser(SerializationFlags flags) + :RsSerializer(RS_SERVICE_TYPE_MSG,SerializeContext::FORMAT_BINARY,flags){} virtual ~RsMsgSerialiser() {} - virtual uint32_t size(RsItem *item) - { - return dynamic_cast(item)->serial_size(m_bConfiguration) ; - } - virtual bool serialise (RsItem *item, void *data, uint32_t *size) - { - return dynamic_cast(item)->serialise(data,*size,m_bConfiguration) ; - } - virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - - virtual RsMsgItem *deserialiseMsgItem(void *data, uint32_t *size); - virtual RsMsgTagType *deserialiseTagItem(void *data, uint32_t *size); - virtual RsMsgTags *deserialiseMsgTagItem(void *data, uint32_t *size); - virtual RsMsgSrcId *deserialiseMsgSrcIdItem(void *data, uint32_t *size); - virtual RsMsgParentId *deserialiseMsgParentIdItem(void *data, uint32_t *size); - virtual RsPublicMsgInviteConfigItem *deserialisePublicMsgInviteConfigItem(void *data, uint32_t *size); - virtual RsMsgGRouterMap *deserialiseMsgGRouterMap(void *data, uint32_t *size); - virtual RsMsgDistantMessagesHashMap *deserialiseMsgDistantMessageHashMap(void *data, uint32_t *size); - - bool m_bConfiguration; // is set to true for saving configuration (enables serialising msgId) + virtual RsItem *create_item(uint16_t service,uint8_t type) const ; }; /**************************************************************************/ diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index 13b4435fd..85a7a9430 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -2,6 +2,10 @@ #include "serialization/rsserializer.h" #include "serialization/rstypeserializer.h" +const SerializationFlags RsSerializer::SERIALIZATION_FLAG_NONE ( 0x0000 ); +const SerializationFlags RsSerializer::SERIALIZATION_FLAG_CONFIG ( 0x0001 ); +const SerializationFlags RsSerializer::SERIALIZATION_FLAG_SIGNATURE ( 0x0002 ); + RsItem *RsSerializer::deserialise(void *data, uint32_t *size) { uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; @@ -15,7 +19,7 @@ RsItem *RsSerializer::deserialise(void *data, uint32_t *size) return NULL ; } - SerializeContext ctx(const_cast(static_cast(data)),*size); + SerializeContext ctx(const_cast(static_cast(data)),*size,mFormat,mFlags); ctx.mOffset = 8 ; item->serial_process(RsItem::DESERIALIZE, ctx) ; @@ -35,7 +39,7 @@ RsItem *RsSerializer::deserialise(void *data, uint32_t *size) bool RsSerializer::serialise(RsItem *item,void *data,uint32_t *size) { - SerializeContext ctx(static_cast(data),0); + SerializeContext ctx(static_cast(data),0,mFormat,mFlags); uint32_t tlvsize = this->size(item) ; @@ -62,7 +66,7 @@ bool RsSerializer::serialise(RsItem *item,void *data,uint32_t *size) uint32_t RsSerializer::size(RsItem *item) { - SerializeContext ctx(NULL,0); + SerializeContext ctx(NULL,0,mFormat,mFlags); ctx.mOffset = 8 ; // header size item->serial_process(RsItem::SIZE_ESTIMATE, ctx) ; @@ -72,7 +76,7 @@ uint32_t RsSerializer::size(RsItem *item) void RsSerializer::print(RsItem *item) { - SerializeContext ctx(NULL,0); + SerializeContext ctx(NULL,0,mFormat,mFlags); std::cerr << "***** RsItem class: \"" << typeid(*item).name() << "\" *****" << std::endl; item->serial_process(RsItem::PRINT, ctx) ; diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index d8ff50b14..db765e36b 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -6,13 +6,28 @@ #include #include "serialiser/rsserial.h" +#include "serialization/rstypeserializer.h" #define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " class RsSerializer: public RsSerialType { public: - RsSerializer(uint16_t service_id) : RsSerialType(RS_PKT_VERSION_SERVICE,service_id) {} + // These are convenience flags to be used by the items when processing the data. The names of the flags + // are not very important. What matters is that the serial_process() method of each item correctly + // deals with the data when it sees the flags, if the serialiser sets them. By default the flags are not + // set and shouldn't be handled. + // When deriving a new serializer, the user can set his own flags, using compatible values + + static const SerializationFlags SERIALIZATION_FLAG_NONE ; // 0x0000 + static const SerializationFlags SERIALIZATION_FLAG_CONFIG ; // 0x0001 + static const SerializationFlags SERIALIZATION_FLAG_SIGNATURE ; // 0x0002 + + RsSerializer(uint16_t service_id, + SerializeContext::SerializationFormat format = SerializeContext::FORMAT_BINARY, + SerializationFlags flags = SERIALIZATION_FLAG_NONE) + + : RsSerialType(RS_PKT_VERSION_SERVICE,service_id),mFormat(format),mFlags(flags) {} /*! create_item * should be overloaded to create the correct type of item depending on the data @@ -28,6 +43,10 @@ class RsSerializer: public RsSerialType bool serialise(RsItem *item,void *data,uint32_t *size) ; uint32_t size(RsItem *item) ; void print(RsItem *item) ; + +private: + SerializeContext::SerializationFormat mFormat ; + SerializationFlags mFlags ; }; diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 1899a26fe..0693331b1 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -11,13 +11,20 @@ class SerializeContext { public: - SerializeContext(uint8_t *data,uint32_t size) - : mData(data),mSize(size),mOffset(0),mOk(true) {} + enum SerializationFormat { + FORMAT_BINARY = 0x01 , + FORMAT_JSON = 0x02 + }; + + SerializeContext(uint8_t *data,uint32_t size,SerializationFormat format,SerializationFlags flags) + : mData(data),mSize(size),mOffset(0),mOk(true),mFormat(format),mFlags(flags) {} unsigned char *mData ; uint32_t mSize ; uint32_t mOffset ; bool mOk ; + SerializationFormat mFormat ; + SerializationFlags mFlags ; }; diff --git a/libretroshare/src/services/p3msgservice.cc b/libretroshare/src/services/p3msgservice.cc index 8781e245b..44c244023 100644 --- a/libretroshare/src/services/p3msgservice.cc +++ b/libretroshare/src/services/p3msgservice.cc @@ -86,7 +86,7 @@ static const uint32_t RS_MSG_DISTANT_MESSAGE_HASH_KEEP_TIME = 2*30*86400 ; // ke p3MsgService::p3MsgService(p3ServiceControl *sc, p3IdService *id_serv) :p3Service(), p3Config(), mIdService(id_serv), mServiceCtrl(sc), mMsgMtx("p3MsgService"), mMsgUniqueId(0) { - _serialiser = new RsMsgSerialiser(); // this serialiser is used for services. It's not the same than the one returned by setupSerialiser(). We need both!! + _serialiser = new RsMsgSerialiser(RsSerializer::SERIALIZATION_FLAG_NONE); // this serialiser is used for services. It's not the same than the one returned by setupSerialiser(). We need both!! addSerialType(_serialiser); mMsgUniqueId = 1 ; // MsgIds are not transmitted, but only used locally as a storage index. As such, thay do not need to be different @@ -519,7 +519,7 @@ RsSerialiser* p3MsgService::setupSerialiser() // this serialiser is used for con { RsSerialiser *rss = new RsSerialiser ; - rss->addSerialType(new RsMsgSerialiser(true)); + rss->addSerialType(new RsMsgSerialiser(RsSerializer::SERIALIZATION_FLAG_CONFIG)); rss->addSerialType(new RsGeneralConfigSerialiser()); return rss; @@ -2024,10 +2024,10 @@ void p3MsgService::sendDistantMsgItem(RsMsgItem *msgitem) // The item is serialized and turned into a generic turtle item. Use use the explicit serialiser to make sure that the msgId is not included - uint32_t msg_serialized_rssize = msgitem->serial_size(false) ; + uint32_t msg_serialized_rssize = RsMsgSerialiser(RsSerializer::SERIALIZATION_FLAG_NONE).size(msgitem) ; RsTemporaryMemory msg_serialized_data(msg_serialized_rssize) ; - if(!msgitem->serialise(msg_serialized_data,msg_serialized_rssize,false)) + if(!RsMsgSerialiser(RsSerializer::SERIALIZATION_FLAG_NONE).serialise(msgitem,msg_serialized_data,&msg_serialized_rssize)) { std::cerr << "(EE) p3MsgService::sendTurtleData(): Serialization error." << std::endl; return ; From 91b04098b64419bcdc038799899d1f45abb10311 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 10:11:24 +0200 Subject: [PATCH 34/94] fixed two memory bugs in serialization code --- libretroshare/src/chat/rschatitems.cc | 2 +- libretroshare/src/rsitems/rsdiscovery2items.cc | 9 ++++----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 75d90e0a4..e30c401c1 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -75,7 +75,7 @@ RsChatAvatarItem::~RsChatAvatarItem() { if(image_data != NULL) { - delete[] image_data ; + free(image_data) ; image_data = NULL ; } } diff --git a/libretroshare/src/rsitems/rsdiscovery2items.cc b/libretroshare/src/rsitems/rsdiscovery2items.cc index e1e939ffa..687f32f21 100644 --- a/libretroshare/src/rsitems/rsdiscovery2items.cc +++ b/libretroshare/src/rsitems/rsdiscovery2items.cc @@ -134,17 +134,16 @@ void RsDiscContactItem::serial_process(SerializeJob j,SerializeContext& ctx) // This is a hack. Normally we should have to different item types, in order to avoid this nonesense. - if( (j == RsItem::DESERIALIZE && GetTlvType( &(((uint8_t *) ctx.mData)[ctx.mOffset]) )==TLV_TYPE_STR_DOMADDR) || isHidden) - { - isHidden = true ; + if(j == RsItem::DESERIALIZE) + isHidden = ( GetTlvType( &(((uint8_t *) ctx.mData)[ctx.mOffset]) )==TLV_TYPE_STR_DOMADDR); + if(isHidden) + { RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_DOMADDR,hiddenAddr,"hiddenAddr"); RsTypeSerializer::serial_process(j,ctx,hiddenPort,"hiddenPort"); } else { - isHidden = false ; - RsTypeSerializer::serial_process(j,ctx,localAddrV4,"localAddrV4"); RsTypeSerializer::serial_process(j,ctx, extAddrV4,"extAddrV4"); RsTypeSerializer::serial_process(j,ctx,localAddrV6,"localAddrV6"); From 08867945f34be33bca05ed835c42d80441ece435 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 10:29:57 +0200 Subject: [PATCH 35/94] fixed bug caused by wrong cast in lobby msg signature validation --- libretroshare/src/chat/distributedchat.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/libretroshare/src/chat/distributedchat.cc b/libretroshare/src/chat/distributedchat.cc index f79b71a18..79c41b2f2 100644 --- a/libretroshare/src/chat/distributedchat.cc +++ b/libretroshare/src/chat/distributedchat.cc @@ -222,7 +222,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const mGixs->requestKey(obj->signature.keyId,peer_list,RsIdentityUsage(RS_SERVICE_TYPE_CHAT,RsIdentityUsage::CHAT_LOBBY_MSG_VALIDATION,RsGxsGroupId(),RsGxsMessageId(),obj->lobby_id)); - uint32_t size = RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).size((RsItem*)obj) ; + uint32_t size = RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).size(dynamic_cast(obj)) ; RsTemporaryMemory memory(size) ; #ifdef DEBUG_CHAT_LOBBIES @@ -230,7 +230,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const std::cerr << " signature id: " << obj->signature.keyId << std::endl; #endif - if(!RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise((RsItem*)obj,memory,&size)) + if(!RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise(dynamic_cast(obj),memory,&size)) { std::cerr << " (EE) Cannot serialise message item. " << std::endl; return false ; @@ -970,10 +970,10 @@ bool DistributedChatService::locked_initLobbyBouncableObject(const ChatLobbyId& // now sign the object, if the lobby expects it - uint32_t size = RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).size((RsItem*)&item) ; + uint32_t size = RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).size(dynamic_cast(&item)) ; RsTemporaryMemory memory(size) ; - if(!RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise((RsItem*)&item,memory,&size)) + if(!RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise(dynamic_cast(&item),memory,&size)) { std::cerr << "(EE) Cannot sign message item. " << std::endl; return false ; From fc82b2083322f07940453e4a8407602a6142e034 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 10:36:22 +0200 Subject: [PATCH 36/94] removed old serialization code in msgs --- .../src/rsitems/rsdiscovery2items.cc | 663 ---------- libretroshare/src/serialiser/rsmsgitems.cc | 1111 ----------------- 2 files changed, 1774 deletions(-) diff --git a/libretroshare/src/rsitems/rsdiscovery2items.cc b/libretroshare/src/rsitems/rsdiscovery2items.cc index 687f32f21..8e4175a9e 100644 --- a/libretroshare/src/rsitems/rsdiscovery2items.cc +++ b/libretroshare/src/rsitems/rsdiscovery2items.cc @@ -156,228 +156,6 @@ void RsDiscContactItem::serial_process(SerializeJob j,SerializeContext& ctx) } /*************************************************************************/ - - - -#ifdef TO_REMOVE -/*************************************************************************/ - -uint32_t RsDiscSerialiser::size(RsItem *i) -{ - RsDiscPgpListItem *pgplist; - RsDiscPgpCertItem *pgpcert; - RsDiscContactItem *contact; - //RsDiscServicesItem *services; - - if (NULL != (pgplist = dynamic_cast(i))) - { - return sizePgpList(pgplist); - } - else if (NULL != (pgpcert = dynamic_cast(i))) - { - return sizePgpCert(pgpcert); - } - else if (NULL != (contact = dynamic_cast(i))) - { - return sizeContact(contact); - } -#if 0 - else if (NULL != (services = dynamic_cast(i))) - { - return sizeServices(services); - } -#endif - return 0; -} - -/* serialise the data to the buffer */ -bool RsDiscSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsDiscPgpListItem *pgplist; - RsDiscPgpCertItem *pgpcert; - RsDiscContactItem *contact; - //RsDiscServicesItem *services; - - if (NULL != (pgplist = dynamic_cast(i))) - { - return serialisePgpList(pgplist, data, pktsize); - } - else if (NULL != (pgpcert = dynamic_cast(i))) - { - return serialisePgpCert(pgpcert, data, pktsize); - } - else if (NULL != (contact = dynamic_cast(i))) - { - return serialiseContact(contact, data, pktsize); - } -#if 0 - else if (NULL != (services = dynamic_cast(i))) - { - return serialiseServices(services, data, pktsize); - } -#endif - - return false; -} - -RsItem *RsDiscSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_DISC != getRsItemService(rstype))) - { - std::cerr << "RsDiscSerialiser::deserialise() Wrong Type" << std::endl; - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_DISC_PGP_LIST: - return deserialisePgpList(data, pktsize); - break; - case RS_PKT_SUBTYPE_DISC_PGP_CERT: - return deserialisePgpCert(data, pktsize); - break; - case RS_PKT_SUBTYPE_DISC_CONTACT: - return deserialiseContact(data, pktsize); - break; -#if 0 - case RS_PKT_SUBTYPE_DISC_SERVICES: - return deserialiseServices(data, pktsize); - break; -#endif - default: - return NULL; - break; - } - return NULL; -} -std::ostream &RsDiscPgpListItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsDiscPgpListItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "mode: " << mode << std::endl; - pgpIdSet.print(out, int_Indent); - - printRsItemEnd(out, "RsDiscPgpList", indent); - return out; -} - - -uint32_t RsDiscSerialiser::sizePgpList(RsDiscPgpListItem *item) -{ - uint32_t s = 8; /* header */ - s += 4; /* mode */ - s += item->pgpIdSet.TlvSize(); - return s; -} -/* serialise the data to the buffer */ -bool RsDiscSerialiser::serialisePgpList(RsDiscPgpListItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizePgpList(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsDiscSerialiser::serialisePgpList() Header: " << ok << std::endl; - std::cerr << "RsDiscSerialiser::serialisePgpList() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, item->mode); - ok &= item->pgpIdSet.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::serialisePgpList() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsDiscPgpListItem *RsDiscSerialiser::deserialisePgpList(void *data, uint32_t *pktsize) { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_DISC != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_DISC_PGP_LIST != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialisePgpList() Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialisePgpList() Not Enough Space" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsDiscPgpListItem *item = new RsDiscPgpListItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &(item->mode)); - ok &= item->pgpIdSet.GetTlv(data, rssize, &offset); - - if (offset != rssize) { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialisePgpList() offset != rssize" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialisePgpList() ok = false" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -#endif - -/*************************************************************************/ -/*************************************************************************/ #if 0 RsDiscServicesItem::~RsDiscServicesItem() @@ -512,445 +290,4 @@ RsDiscServicesItem *RsDiscSerialiser::deserialiseServices(void *data, uint32_t * return item; } -RsDiscPgpCertItem::~RsDiscPgpCertItem() -{ - return; -} - -std::ostream &RsDiscPgpCertItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsDiscPgpCertItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "pgpId: " << pgpId << std::endl; - printIndent(out, int_Indent); - out << "pgpCert: " << pgpCert << std::endl; - - printRsItemEnd(out, "RsDiscPgpCert", indent); - return out; -} - - -uint32_t RsDiscSerialiser::sizePgpCert(RsDiscPgpCertItem *item) -{ - uint32_t s = 8; /* header */ - s += item->pgpId.serial_size(); - s += GetTlvStringSize(item->pgpCert); - return s; -} -/* serialise the data to the buffer */ -bool RsDiscSerialiser::serialisePgpCert(RsDiscPgpCertItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizePgpCert(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsDiscSerialiser::serialisePgpCert() Header: " << ok << std::endl; - std::cerr << "RsDiscSerialiser::serialisePgpCert() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->pgpId.serialise(data, tlvsize, offset) ; - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PGPCERT, item->pgpCert); - - if (offset != tlvsize) { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::serialisePgpCert() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsDiscPgpCertItem *RsDiscSerialiser::deserialisePgpCert(void *data, uint32_t *pktsize) { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_DISC != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_DISC_PGP_CERT != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialisePgpCert() Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialisePgpCert() Not Enough Space" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsDiscPgpCertItem *item = new RsDiscPgpCertItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->pgpId.deserialise(data, rssize, offset) ; - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PGPCERT, item->pgpCert); - - if (offset != rssize) { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialisePgpCert() offset != rssize" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialisePgpCert() ok = false" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -/*************************************************************************/ - - -RsDiscContactItem::~RsDiscContactItem() -{ - return; -} - -std::ostream &RsDiscContactItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsDiscContact", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "pgpId: " << pgpId << std::endl; - - printIndent(out, int_Indent); - out << "sslId: " << sslId << std::endl; - - printIndent(out, int_Indent); - out << "location: " << location << std::endl; - - printIndent(out, int_Indent); - out << "version: " << version << std::endl; - - printIndent(out, int_Indent); - out << "netMode: " << netMode << std::endl; - - printIndent(out, int_Indent); - out << "vs_disc: " << vs_disc << std::endl; - - printIndent(out, int_Indent); - out << "vs_dht: " << vs_dht << std::endl; - - printIndent(out, int_Indent); - out << "lastContact: " << lastContact << std::endl; - - if (isHidden) - { - printIndent(out, int_Indent); - out << "hiddenAddr: " << hiddenAddr << std::endl; - - printIndent(out, int_Indent); - out << "hiddenPort: " << hiddenPort << std::endl; - } - else - { - printIndent(out, int_Indent); - out << "localAddrV4: " << std::endl; - localAddrV4.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "extAddrV4: " << std::endl; - extAddrV4.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "localAddrV6: " << std::endl; - localAddrV6.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "extAddrV6: " << std::endl; - extAddrV6.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "DynDNS: " << dyndns << std::endl; - - printIndent(out, int_Indent); - out << "localAddrList: " << std::endl; - localAddrList.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "extAddrList: " << std::endl; - extAddrList.print(out, int_Indent); - } - - printRsItemEnd(out, "RsDiscContact", indent); - return out; -} - -uint32_t RsDiscSerialiser::sizeContact(RsDiscContactItem *item) -{ - uint32_t s = 8; /* header */ - s += item->pgpId.serial_size(); - s += item->sslId.serial_size(); - - s += GetTlvStringSize(item->location); - s += GetTlvStringSize(item->version); - - s += 4; // netMode - s += 2; // vs_disc - s += 2; // vs_dht - s += 4; // last contact - - if (item->isHidden) - { - s += GetTlvStringSize(item->hiddenAddr); - s += 2; /* hidden port */ - } - else - { - s += item->localAddrV4.TlvSize(); /* localaddr */ - s += item->extAddrV4.TlvSize(); /* remoteaddr */ - - s += item->currentConnectAddress.TlvSize() ; - - s += item->localAddrV6.TlvSize(); /* localaddr */ - s += item->extAddrV6.TlvSize(); /* remoteaddr */ - - s += GetTlvStringSize(item->dyndns); - - //add the size of the ip list - s += item->localAddrList.TlvSize(); - s += item->extAddrList.TlvSize(); - } - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsDiscSerialiser::sizeContact() Total Size: " << s << std::endl; -#endif - - return s; -} - -/* serialise the data to the buffer */ -bool RsDiscSerialiser::serialiseContact(RsDiscContactItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeContact(item); - uint32_t offset = 0; - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsDiscSerialiser::serialiseContact() tlvsize: " << tlvsize; - std::cerr << std::endl; -#endif - - if (*pktsize < tlvsize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::serialiseContact() ERROR not enough space" << std::endl; - std::cerr << "RsDiscSerialiser::serialiseContact() ERROR *pktsize: " << *pktsize << " tlvsize: " << tlvsize; - std::cerr << std::endl; -#endif - return false; /* not enough space */ - } - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsDiscSerialiser::serialiseContact() Header: " << ok << std::endl; - std::cerr << "RsDiscSerialiser::serialiseContact() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->pgpId.serialise(data, tlvsize, offset) ; - ok &= item->sslId.serialise(data, tlvsize, offset) ; - - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->location); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VERSION, item->version); - - ok &= setRawUInt32(data, tlvsize, &offset, item->netMode); - ok &= setRawUInt16(data, tlvsize, &offset, item->vs_disc); - ok &= setRawUInt16(data, tlvsize, &offset, item->vs_dht); - ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */ - - if (item->isHidden) - { - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DOMADDR, item->hiddenAddr); - ok &= setRawUInt16(data, tlvsize, &offset, item->hiddenPort); - } - else - { - ok &= item->localAddrV4.SetTlv(data, tlvsize, &offset); - ok &= item->extAddrV4.SetTlv(data, tlvsize, &offset); - ok &= item->localAddrV6.SetTlv(data, tlvsize, &offset); - ok &= item->extAddrV6.SetTlv(data, tlvsize, &offset); - - ok &= item->currentConnectAddress.SetTlv(data, tlvsize, &offset); - - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns); - - ok &= item->localAddrList.SetTlv(data, tlvsize, &offset); - ok &= item->extAddrList.SetTlv(data, tlvsize, &offset); - } - - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::serialiseContact() Size Error: " << tlvsize << " != " << offset << std::endl; -#endif - } - - return ok; -} - -RsDiscContactItem *RsDiscSerialiser::deserialiseContact(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseContact() Pkt Type: " << std::hex << rstype << std::dec; - std::cerr << "RsDiscSerialiser::deserialiseContact() Pkt Size: " << rssize << std::endl; -#endif - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_DISC != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_DISC_CONTACT != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseContact() Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseContact() Not enough space" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsDiscContactItem *item = new RsDiscContactItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->pgpId.deserialise(data, rssize, offset) ; - ok &= item->sslId.deserialise(data, rssize, offset) ; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->location); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VERSION, item->version); - - ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */ - ok &= getRawUInt16(data, rssize, &offset, &(item->vs_disc)); /* Mandatory */ - ok &= getRawUInt16(data, rssize, &offset, &(item->vs_dht)); /* Mandatory */ - ok &= getRawUInt32(data, rssize, &offset, &(item->lastContact)); - - if (rssize < offset + TLV_HEADER_SIZE) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseContact() missized" << std::endl; -#endif - /* no extra */ - delete item; - return NULL; - } - - uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[offset]) ); - - if (tlvtype == TLV_TYPE_STR_DOMADDR) - { - item->isHidden = true; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DOMADDR, item->hiddenAddr); - ok &= getRawUInt16(data, rssize, &offset, &(item->hiddenPort)); /* Mandatory */ - - } - else - { - item->isHidden = false; - - ok &= item->localAddrV4.GetTlv(data, rssize, &offset); - ok &= item->extAddrV4.GetTlv(data, rssize, &offset); - ok &= item->localAddrV6.GetTlv(data, rssize, &offset); - ok &= item->extAddrV6.GetTlv(data, rssize, &offset); - - ok &= item->currentConnectAddress.GetTlv(data, rssize, &offset); - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns); - ok &= item->localAddrList.GetTlv(data, rssize, &offset); - ok &= item->extAddrList.GetTlv(data, rssize, &offset); - } - - - if (offset != rssize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseContact() offset != rssize" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseContact() ok = false" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} #endif diff --git a/libretroshare/src/serialiser/rsmsgitems.cc b/libretroshare/src/serialiser/rsmsgitems.cc index 9fc3d7e40..6dee2f2be 100644 --- a/libretroshare/src/serialiser/rsmsgitems.cc +++ b/libretroshare/src/serialiser/rsmsgitems.cc @@ -179,1114 +179,3 @@ void RsMsgTags::clear() tagIds.clear(); } -#ifdef TO_REMOVE -std::ostream &RsMsgItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsMsgItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "msgId (not serialised): " << msgId << std::endl; - printIndent(out, int_Indent); - out << "msgFlags: " << msgFlags << std::endl; - - printIndent(out, int_Indent); - out << "sendTime: " << sendTime << std::endl; - printIndent(out, int_Indent); - out << "recvTime: " << recvTime << std::endl; - - printIndent(out, int_Indent); - out << "Message To: " << std::endl; - rspeerid_msgto.print(out, int_Indent); - rsgxsid_msgto.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "Message CC: " << std::endl; - rspeerid_msgcc.print(out, int_Indent); - rsgxsid_msgcc.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "Message BCC: " << std::endl; - rspeerid_msgbcc.print(out, int_Indent); - rsgxsid_msgbcc.print(out, int_Indent); - - printIndent(out, int_Indent); - std::string cnv_subject(subject.begin(), subject.end()); - out << "subject: " << cnv_subject << std::endl; - - printIndent(out, int_Indent); - std::string cnv_message(message.begin(), message.end()); - out << "msg: " << cnv_message << std::endl; - - printIndent(out, int_Indent); - out << "Attachment: " << std::endl; - attachment.print(out, int_Indent); - - printRsItemEnd(out, "RsMsgItem", indent); - return out; -} -std::ostream& RsPublicMsgInviteConfigItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsPublicMsgInviteConfigItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "hash : " << hash << std::endl; - - printIndent(out, int_Indent); - out << "timt : " << time_stamp << std::endl; - - printRsItemEnd(out, "RsPublicMsgInviteConfigItem", indent); - - return out; -} -std::ostream& RsMsgTagType::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsMsgTagType", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "rgb_color : " << rgb_color << std::endl; - - - printIndent(out, int_Indent); - out << "text: " << text << std::endl; - - printIndent(out, int_Indent); - out << "tagId: " << tagId << std::endl; - - printRsItemEnd(out, "RsMsgTagTypeItem", indent); - - return out; -} - -std::ostream& RsMsgTags::print(std::ostream &out, uint16_t indent) -{ - - printRsItemBase(out, "RsMsgTagsItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "msgId : " << msgId << std::endl; - - std::list::iterator it; - - for(it=tagIds.begin(); it != tagIds.end(); ++it) - { - printIndent(out, int_Indent); - out << "tagId : " << *it << std::endl; - } - - printRsItemEnd(out, "RsMsgTags", indent); - - return out; -} - -uint32_t RsMsgItem::serial_size(bool m_bConfiguration) -{ - uint32_t s = 8; /* header */ - s += 4; /* msgFlags */ - s += 4; /* sendTime */ - s += 4; /* recvTime */ - - s += GetTlvStringSize(subject); - s += GetTlvStringSize(message); - - s += rspeerid_msgto.TlvSize(); - s += rspeerid_msgcc.TlvSize(); - s += rspeerid_msgbcc.TlvSize(); - - s += rsgxsid_msgto.TlvSize(); - s += rsgxsid_msgcc.TlvSize(); - s += rsgxsid_msgbcc.TlvSize(); - - s += attachment.TlvSize(); - - if (m_bConfiguration) { - // serialise msgId too - s += 4; - } - - return s; -} - -/* serialise the data to the buffer */ -bool RsMsgItem::serialise(void *data, uint32_t& pktsize,bool config) -{ - uint32_t tlvsize = serial_size( config) ; - uint32_t offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsMsgSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, msgFlags); - ok &= setRawUInt32(data, tlvsize, &offset, sendTime); - ok &= setRawUInt32(data, tlvsize, &offset, recvTime); - - ok &= SetTlvString(data,tlvsize,&offset,TLV_TYPE_STR_SUBJECT,subject); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, message); - - ok &= rspeerid_msgto.SetTlv(data, tlvsize, &offset); - ok &= rspeerid_msgcc.SetTlv(data, tlvsize, &offset); - ok &= rspeerid_msgbcc.SetTlv(data, tlvsize, &offset); - - ok &= rsgxsid_msgto.SetTlv(data, tlvsize, &offset); - ok &= rsgxsid_msgcc.SetTlv(data, tlvsize, &offset); - ok &= rsgxsid_msgbcc.SetTlv(data, tlvsize, &offset); - - ok &= attachment.SetTlv(data, tlvsize, &offset); - - if (config) // serialise msgId too - ok &= setRawUInt32(data, tlvsize, &offset, msgId); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsMsgSerialiser::serialiseItem() Size Error! " << std::endl; - } - - return ok; -} - -RsMsgItem *RsMsgSerialiser::deserialiseMsgItem(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_DEFAULT != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsMsgItem *item = new RsMsgItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &(item->msgFlags)); - ok &= getRawUInt32(data, rssize, &offset, &(item->sendTime)); - ok &= getRawUInt32(data, rssize, &offset, &(item->recvTime)); - - ok &= GetTlvString(data,rssize,&offset,TLV_TYPE_STR_SUBJECT,item->subject); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->message); - - ok &= item->rspeerid_msgto.GetTlv(data, rssize, &offset); - ok &= item->rspeerid_msgcc.GetTlv(data, rssize, &offset); - ok &= item->rspeerid_msgbcc.GetTlv(data, rssize, &offset); - ok &= item->rsgxsid_msgto.GetTlv(data, rssize, &offset); - ok &= item->rsgxsid_msgcc.GetTlv(data, rssize, &offset); - ok &= item->rsgxsid_msgbcc.GetTlv(data, rssize, &offset); - - ok &= item->attachment.GetTlv(data, rssize, &offset); - - if (m_bConfiguration) { - // deserialise msgId too - // ok &= getRawUInt32(data, rssize, &offset, &(item->msgId)); - getRawUInt32(data, rssize, &offset, &(item->msgId)); //use this line for backward compatibility - } - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} -uint32_t RsPublicMsgInviteConfigItem::serial_size(bool) -{ - uint32_t s = 8; /* header */ - - s += GetTlvStringSize(hash); - s += 4; /* time_stamp */ - - return s; -} - -uint32_t RsMsgTagType::serial_size(bool) -{ - uint32_t s = 8; /* header */ - - s += GetTlvStringSize(text); - s += 4; /* color */ - s += 4; /* tag id */ - - return s; -} -bool RsPublicMsgInviteConfigItem::serialise(void *data, uint32_t& pktsize,bool config) -{ - uint32_t tlvsize = serial_size(config) ; - uint32_t offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Header: " << ok << std::endl; - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - - ok &= SetTlvString(data,tlvsize,&offset, TLV_TYPE_STR_HASH_SHA1, hash); - ok &= setRawUInt32(data,tlvsize,&offset, time_stamp); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Size Error! " << std::endl; - } - - return ok; -} -bool RsMsgTagType::serialise(void *data, uint32_t& pktsize,bool config) -{ - uint32_t tlvsize = serial_size( config) ; - uint32_t offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Header: " << ok << std::endl; - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - - ok &= SetTlvString(data,tlvsize,&offset, TLV_TYPE_STR_NAME, text); - ok &= setRawUInt32(data, tlvsize, &offset, rgb_color); - ok &= setRawUInt32(data, tlvsize, &offset, tagId); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Size Error! " << std::endl; - } - - return ok; -} -RsPublicMsgInviteConfigItem* RsMsgSerialiser::deserialisePublicMsgInviteConfigItem(void *data,uint32_t* pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_MSG_INVITE != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsPublicMsgInviteConfigItem *item = new RsPublicMsgInviteConfigItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= GetTlvString(data,rssize,&offset,TLV_TYPE_STR_HASH_SHA1,item->hash); - - uint32_t ts ; - ok &= getRawUInt32(data, rssize, &offset, &ts) ; - item->time_stamp = ts ; - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - - -RsMsgTagType* RsMsgSerialiser::deserialiseTagItem(void *data,uint32_t* pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_MSG_TAG_TYPE != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsMsgTagType *item = new RsMsgTagType(); - item->clear(); - - /* skip the header */ - offset += 8; - - - /* get mandatory parts first */ - ok &= GetTlvString(data,rssize,&offset,TLV_TYPE_STR_NAME,item->text); - ok &= getRawUInt32(data, rssize, &offset, &(item->rgb_color)); - ok &= getRawUInt32(data, rssize, &offset, &(item->tagId)); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -uint32_t RsMsgTags::serial_size(bool) -{ - uint32_t s = 8; /* header */ - - s += 4; /* msgId */ - s += tagIds.size() * 4; /* tagIds */ - - return s; -} -bool RsMsgTags::serialise(void *data, uint32_t& pktsize,bool config) -{ - uint32_t tlvsize = serial_size( config) ; - uint32_t offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Header: " << ok << std::endl; - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - ok &= setRawUInt32(data,tlvsize,&offset, msgId); - - std::list::iterator mit = tagIds.begin(); - for(;mit != tagIds.end(); ++mit) - ok &= setRawUInt32(data, tlvsize, &offset, *mit); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsMsgSerialiser::serialiseMsgTagItem() Size Error! " << std::endl; - } - - return ok; -} - -RsMsgTags* RsMsgSerialiser::deserialiseMsgTagItem(void* data, uint32_t* pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_MSG_TAGS != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsMsgTags *item = new RsMsgTags(); - item->clear(); - - /* skip the header */ - offset += 8; - - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &item->msgId); - - uint32_t tagId; - while (offset != rssize) - { - tagId = 0; - - ok &= getRawUInt32(data, rssize, &offset, &tagId); - - item->tagIds.push_back(tagId); - } - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - - -/************************************** Message SrcId **********************/ - -std::ostream& RsMsgSrcId::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsMsgSrcIdItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "msgId : " << msgId << std::endl; - - printIndent(out, int_Indent); - out << "SrcId: " << srcId << std::endl; - - - printRsItemEnd(out, "RsMsgItem", indent); - - return out; -} - -void RsMsgSrcId::clear() -{ - msgId = 0; - srcId.clear(); - - return; -} - -uint32_t RsMsgSrcId::serial_size(bool) -{ - uint32_t s = 8; /* header */ - - s += 4; - s += srcId.serial_size() ; - - return s; -} -bool RsMsgSrcId::serialise(void *data, uint32_t& pktsize,bool config) -{ - uint32_t tlvsize = serial_size(config) ; - uint32_t offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialiseMsgSrcIdItem() Header: " << ok << std::endl; - std::cerr << "RsMsgSerialiser::serialiseMsgSrcIdItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - ok &= setRawUInt32(data, tlvsize, &offset, msgId); - ok &= srcId.serialise(data, tlvsize, offset) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsMsgSerialiser::serialiseMsgSrcIdItem() Size Error! " << std::endl; - } - - return ok; -} - -RsMsgSrcId* RsMsgSerialiser::deserialiseMsgSrcIdItem(void* data, uint32_t* pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_MSG_SRC_TAG != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsMsgSrcId *item = new RsMsgSrcId(); - item->clear(); - - /* skip the header */ - offset += 8; - - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &(item->msgId)); - ok &= item->srcId.deserialise(data, rssize, offset); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/************************* end of definition of msgSrcId serialisation functions ************************/ - -std::ostream& RsMsgGRouterMap::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsMsgGRouterMap", indent); - uint16_t int_Indent = indent + 2; - - for(std::map::const_iterator it(ongoing_msgs.begin());it!=ongoing_msgs.end();++it) - { - printIndent(out, int_Indent); - out << " " << std::hex << it->first << std::dec << " : " << it->second << std::endl; - } - - printRsItemEnd(out, "RsMsgGRouterMap", indent); - - return out; -} -uint32_t RsMsgGRouterMap::serial_size(bool) -{ - uint32_t s = 8; /* header */ - - s += 4; // number of entries - s += (8+4)*ongoing_msgs.size(); // entries - - return s; -} - -bool RsMsgGRouterMap::serialise(void *data, uint32_t& pktsize,bool config) -{ - uint32_t tlvsize = serial_size( config) ; - uint32_t offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialiseMsgParentIdItem() Header: " << ok << std::endl; - std::cerr << "RsMsgSerialiser::serialiseMsgParentIdItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - ok &= setRawUInt32(data, tlvsize, &offset, ongoing_msgs.size()); - - for(std::map::const_iterator it=ongoing_msgs.begin();ok && it!=ongoing_msgs.end();++it) - { - ok &= setRawUInt64(data, tlvsize, &offset, it->first); - ok &= setRawUInt32(data, tlvsize, &offset, it->second); - } - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsMsgSerialiser::serialiseMsgGRouterMap() Size Error! " << std::endl; - } - - return ok; -} - -RsMsgGRouterMap* RsMsgSerialiser::deserialiseMsgGRouterMap(void* data, uint32_t* pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_MSG_GROUTER_MAP != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsMsgGRouterMap *item = new RsMsgGRouterMap(); - item->clear(); - - /* skip the header */ - offset += 8; - - uint32_t s=0 ; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &s); - - for(uint32_t i=0;iongoing_msgs.insert(std::make_pair(routing_id,mid)) ; - } - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/************************* end of definition of msgGRouterMap serialisation functions ************************/ - -/************************* definition of msgDistantMessageMap serialisation functions ************************/ - -std::ostream& RsMsgDistantMessagesHashMap::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsMsgDistantMessagesHashMap", indent); - uint16_t int_Indent = indent + 2; - - for(std::map::const_iterator it(hash_map.begin());it!=hash_map.end();++it) - { - printIndent(out, int_Indent); - out << " " << std::hex << it->first << std::dec << " : " << it->second << std::endl; - } - - printRsItemEnd(out, "RsMsgDistantMessagesHashMap", indent); - - return out; -} - -void RsMsgDistantMessagesHashMap::clear() -{ - hash_map.clear() ; - - return; -} - -uint32_t RsMsgDistantMessagesHashMap::serial_size(bool) -{ - uint32_t s = 8; /* header */ - - s += 4; // number of entries - s += (Sha1CheckSum::SIZE_IN_BYTES+4)*hash_map.size(); // entries - - return s; -} -bool RsMsgDistantMessagesHashMap::serialise(void *data, uint32_t& pktsize,bool config) -{ - uint32_t tlvsize = serial_size(config) ; - uint32_t offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialiseMsgDistantMessagesHashMap() Header: " << ok << std::endl; - std::cerr << "RsMsgSerialiser::serialiseMsgDistantMessagesHashMap() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - ok &= setRawUInt32(data, tlvsize, &offset, hash_map.size()); - - for(std::map::const_iterator it=hash_map.begin();ok && it!=hash_map.end();++it) - { - ok &= it->first.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, it->second); - } - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsMsgSerialiser::serialiseMsgDistantMessagesHashMap() Size Error! " << std::endl; - } - - return ok; -} - -RsMsgDistantMessagesHashMap* RsMsgSerialiser::deserialiseMsgDistantMessageHashMap(void* data, uint32_t* pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsMsgDistantMessagesHashMap *item = new RsMsgDistantMessagesHashMap(); - item->clear(); - - /* skip the header */ - offset += 8; - - uint32_t s=0 ; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &s); - - for(uint32_t i=0;ihash_map.insert(std::make_pair(s,tm)) ; - } - - if (offset != rssize) - { - /* error */ - std::cerr << "(EE) size error in packet deserialisation: p3MsgItem, subtype " << getRsItemSubType(rstype) << ". offset=" << offset << " != rssize=" << rssize << std::endl; - delete item; - return NULL; - } - - if (!ok) - { - std::cerr << "(EE) size error in packet deserialisation: p3MsgItem, subtype " << getRsItemSubType(rstype) << std::endl; - delete item; - return NULL; - } - - return item; -} -/************************************** Message ParentId **********************/ - -std::ostream& RsMsgParentId::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsMsgParentIdItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "msgId : " << msgId << std::endl; - - printIndent(out, int_Indent); - out << "msgParentId: " << msgParentId << std::endl; - - - printRsItemEnd(out, "RsMsgParentId", indent); - - return out; -} - -void RsMsgParentId::clear() -{ - msgId = 0; - msgParentId = 0; - - return; -} - -uint32_t RsMsgParentId::serial_size(bool) -{ - uint32_t s = 8; /* header */ - - s += 4; // srcId - s += 4; // msgParentId - - return s; -} -bool RsMsgParentId::serialise(void *data, uint32_t& pktsize,bool config) -{ - uint32_t tlvsize = serial_size( config) ; - uint32_t offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialiseMsgParentIdItem() Header: " << ok << std::endl; - std::cerr << "RsMsgSerialiser::serialiseMsgParentIdItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - ok &= setRawUInt32(data, tlvsize, &offset, msgId); - ok &= setRawUInt32(data, tlvsize, &offset, msgParentId); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsMsgSerialiser::serialiseMsgParentIdItem() Size Error! " << std::endl; - } - - return ok; -} - -RsMsgParentId* RsMsgSerialiser::deserialiseMsgParentIdItem(void* data, uint32_t* pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_MSG_PARENT_TAG != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsMsgParentId *item = new RsMsgParentId(); - item->clear(); - - /* skip the header */ - offset += 8; - - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &(item->msgId)); - ok &= getRawUInt32(data, rssize, &offset, &(item->msgParentId)); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/************************* end of definition of msgParentId serialisation functions ************************/ - -RsItem* RsMsgSerialiser::deserialise(void *data, uint32_t *pktsize) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::deserialise()" << std::endl; -#endif - - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_MSG != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_DEFAULT: return deserialiseMsgItem(data, pktsize); - case RS_PKT_SUBTYPE_MSG_SRC_TAG: return deserialiseMsgSrcIdItem(data, pktsize); - case RS_PKT_SUBTYPE_MSG_PARENT_TAG: return deserialiseMsgParentIdItem(data, pktsize); - case RS_PKT_SUBTYPE_MSG_TAG_TYPE: return deserialiseTagItem(data, pktsize); - case RS_PKT_SUBTYPE_MSG_INVITE: return deserialisePublicMsgInviteConfigItem(data, pktsize); - case RS_PKT_SUBTYPE_MSG_TAGS: return deserialiseMsgTagItem(data, pktsize); - case RS_PKT_SUBTYPE_MSG_GROUTER_MAP: return deserialiseMsgGRouterMap(data, pktsize); - case RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP: return deserialiseMsgDistantMessageHashMap(data, pktsize); - default: - return NULL; - break; - } - - return NULL; -} - - -/*************************************************************************/ - -#endif - - From 5071c4bc7f30b43afe342a116217c547410291d6 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 11:00:57 +0200 Subject: [PATCH 37/94] moved msgitems to rsitems/ --- libretroshare/src/{serialiser => rsitems}/rsmsgitems.cc | 0 libretroshare/src/{serialiser => rsitems}/rsmsgitems.h | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsmsgitems.cc (100%) rename libretroshare/src/{serialiser => rsitems}/rsmsgitems.h (100%) diff --git a/libretroshare/src/serialiser/rsmsgitems.cc b/libretroshare/src/rsitems/rsmsgitems.cc similarity index 100% rename from libretroshare/src/serialiser/rsmsgitems.cc rename to libretroshare/src/rsitems/rsmsgitems.cc diff --git a/libretroshare/src/serialiser/rsmsgitems.h b/libretroshare/src/rsitems/rsmsgitems.h similarity index 100% rename from libretroshare/src/serialiser/rsmsgitems.h rename to libretroshare/src/rsitems/rsmsgitems.h From f6aaee73827e8767c7c518c15d2de3fabc8416db Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 11:01:45 +0200 Subject: [PATCH 38/94] converted RTT items to new serialization --- libretroshare/src/chat/distantchat.cc | 18 ++++---- libretroshare/src/chat/p3chatservice.h | 2 +- libretroshare/src/libretroshare.pro | 4 +- libretroshare/src/pqi/p3historymgr.cc | 2 +- libretroshare/src/rsitems/rsmsgitems.cc | 3 +- libretroshare/src/serialiser/rsrttitems.cc | 28 +++++++++++++ libretroshare/src/serialiser/rsrttitems.h | 42 +++++++------------ libretroshare/src/serialiser/rsserial.cc | 2 +- .../src/serialization/rsserializer.h | 9 ++-- libretroshare/src/services/p3msgservice.h | 2 +- 10 files changed, 65 insertions(+), 47 deletions(-) diff --git a/libretroshare/src/chat/distantchat.cc b/libretroshare/src/chat/distantchat.cc index 8bb8b8d17..7345aa274 100644 --- a/libretroshare/src/chat/distantchat.cc +++ b/libretroshare/src/chat/distantchat.cc @@ -35,17 +35,17 @@ #include "util/rsmemory.h" #include "util/rsprint.h" -#include +#include "rsitems/rsmsgitems.h" -#include -#include -#include +#include "retroshare/rsmsgs.h" +#include "retroshare/rsidentity.h" +#include "retroshare/rsiface.h" -#include -#include -#include -#include -#include +#include "rsserver/p3face.h" +#include "services/p3idservice.h" +#include "gxs/gxssecurity.h" +#include "turtle/p3turtle.h" +#include "retroshare/rsids.h" #include "distantchat.h" //#define DEBUG_DISTANT_CHAT diff --git a/libretroshare/src/chat/p3chatservice.h b/libretroshare/src/chat/p3chatservice.h index 3096309b0..482a61c6e 100644 --- a/libretroshare/src/chat/p3chatservice.h +++ b/libretroshare/src/chat/p3chatservice.h @@ -31,7 +31,7 @@ #include #include -#include "serialiser/rsmsgitems.h" +#include "rsitems/rsmsgitems.h" #include "services/p3service.h" #include "pqi/pqiservicemonitor.h" #include "chat/distantchat.h" diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 15ab467b3..4d94f4c71 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -458,7 +458,7 @@ HEADERS += rsitems/itempriorities.h \ serialiser/rsserviceserialiser.h \ serialiser/rsconfigitems.h \ serialiser/rshistoryitems.h \ - serialiser/rsmsgitems.h \ + rsitems/rsmsgitems.h \ serialiser/rsserial.h \ rsitems/rsserviceids.h \ serialiser/rsserviceitems.h \ @@ -612,7 +612,7 @@ SOURCES += serialiser/rsbaseserial.cc \ serialiser/rsserviceserialiser.cc \ serialiser/rsconfigitems.cc \ serialiser/rshistoryitems.cc \ - serialiser/rsmsgitems.cc \ + rsitems/rsmsgitems.cc \ serialiser/rsserial.cc \ serialiser/rsstatusitems.cc \ serialiser/rstlvaddrs.cc \ diff --git a/libretroshare/src/pqi/p3historymgr.cc b/libretroshare/src/pqi/p3historymgr.cc index d190a903b..5739ff94a 100644 --- a/libretroshare/src/pqi/p3historymgr.cc +++ b/libretroshare/src/pqi/p3historymgr.cc @@ -30,7 +30,7 @@ #include "serialiser/rsconfigitems.h" #include "retroshare/rsiface.h" #include "retroshare/rspeers.h" -#include "serialiser/rsmsgitems.h" +#include "rsitems/rsmsgitems.h" #include "rsserver/p3face.h" #include "util/rsstring.h" diff --git a/libretroshare/src/rsitems/rsmsgitems.cc b/libretroshare/src/rsitems/rsmsgitems.cc index 6dee2f2be..7405f37e0 100644 --- a/libretroshare/src/rsitems/rsmsgitems.cc +++ b/libretroshare/src/rsitems/rsmsgitems.cc @@ -27,9 +27,10 @@ #include #include #include "serialiser/rsbaseserial.h" -#include "serialiser/rsmsgitems.h" #include "serialiser/rstlvbase.h" +#include "rsitems/rsmsgitems.h" + #include "serialization/rstypeserializer.h" /*** diff --git a/libretroshare/src/serialiser/rsrttitems.cc b/libretroshare/src/serialiser/rsrttitems.cc index 8f5c136e7..5965f1068 100644 --- a/libretroshare/src/serialiser/rsrttitems.cc +++ b/libretroshare/src/serialiser/rsrttitems.cc @@ -36,7 +36,34 @@ /*************************************************************************/ +RsItem *RsRttSerialiser::create_item(uint16_t service,uint8_t type) const +{ + if(service != RS_SERVICE_TYPE_RTT) + return NULL ; + switch(type) + { + case RS_PKT_SUBTYPE_RTT_PING: return new RsRttPingItem() ; //= 0x01; + case RS_PKT_SUBTYPE_RTT_PONG: return new RsRttPongItem() ; // = 0x02; + default: + return NULL ; + } +} + +void RsRttPingItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mSeqNo,"mSeqNo") ; + RsTypeSerializer::serial_process(j,ctx,mPingTS,"mPingTS") ; +} + +void RsRttPongItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mSeqNo,"mSeqNo") ; + RsTypeSerializer::serial_process(j,ctx,mPingTS,"mPingTS") ; + RsTypeSerializer::serial_process(j,ctx,mPongTS,"mPongTS") ; +} + +#ifdef TO_REMOVE RsRttPingItem::~RsRttPingItem() { return; @@ -370,4 +397,5 @@ RsItem* RsRttSerialiser::deserialise(void *data, uint32_t *pktsize) /*************************************************************************/ +#endif diff --git a/libretroshare/src/serialiser/rsrttitems.h b/libretroshare/src/serialiser/rsrttitems.h index 11a6b8889..cad02062e 100644 --- a/libretroshare/src/serialiser/rsrttitems.h +++ b/libretroshare/src/serialiser/rsrttitems.h @@ -31,6 +31,8 @@ #include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" +#include "serialization/rsserializer.h" + /**************************************************************************/ const uint8_t RS_PKT_SUBTYPE_RTT_PING = 0x01; @@ -39,12 +41,11 @@ const uint8_t RS_PKT_SUBTYPE_RTT_PONG = 0x02; class RsRttItem: public RsItem { public: - RsRttItem(uint8_t chat_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_RTT,chat_subtype) + RsRttItem(uint8_t subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_RTT,subtype) { setPriorityLevel(QOS_PRIORITY_RS_RTT_PING) ;} // should be refined later. virtual ~RsRttItem() {}; virtual void clear() {}; - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0 ; }; class RsRttPingItem: public RsRttItem @@ -52,9 +53,10 @@ class RsRttPingItem: public RsRttItem public: RsRttPingItem() :RsRttItem(RS_PKT_SUBTYPE_RTT_PING) {} - virtual ~RsRttPingItem(); - virtual void clear(); - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual ~RsRttPingItem(){} + virtual void clear(){} + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); uint32_t mSeqNo; uint64_t mPingTS; @@ -65,9 +67,10 @@ class RsRttPongItem: public RsRttItem public: RsRttPongItem() :RsRttItem(RS_PKT_SUBTYPE_RTT_PONG) {} - virtual ~RsRttPongItem(); - virtual void clear(); - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual ~RsRttPongItem(){} + virtual void clear(){} + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); uint32_t mSeqNo; uint64_t mPingTS; @@ -75,29 +78,14 @@ class RsRttPongItem: public RsRttItem }; -class RsRttSerialiser: public RsSerialType +class RsRttSerialiser: public RsSerializer { public: - RsRttSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_RTT) - { return; } + RsRttSerialiser() :RsSerializer(RS_SERVICE_TYPE_RTT) {} -virtual ~RsRttSerialiser() { return; } + virtual ~RsRttSerialiser(){} -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - -virtual uint32_t sizeRttPingItem(RsRttPingItem *); -virtual bool serialiseRttPingItem (RsRttPingItem *item, void *data, uint32_t *size); -virtual RsRttPingItem *deserialiseRttPingItem(void *data, uint32_t *size); - -virtual uint32_t sizeRttPongItem(RsRttPongItem *); -virtual bool serialiseRttPongItem (RsRttPongItem *item, void *data, uint32_t *size); -virtual RsRttPongItem *deserialiseRttPongItem(void *data, uint32_t *size); - + virtual RsItem *create_item(uint16_t service,uint8_t type) const; }; /**************************************************************************/ diff --git a/libretroshare/src/serialiser/rsserial.cc b/libretroshare/src/serialiser/rsserial.cc index 8624b5304..30fed530e 100644 --- a/libretroshare/src/serialiser/rsserial.cc +++ b/libretroshare/src/serialiser/rsserial.cc @@ -438,7 +438,7 @@ RsItem * RsSerialiser::deserialise(void *data, uint32_t *size) uint32_t failedtype = getRsItemId(data); std::cerr << "RsSerialiser::deserialise() FAILED PACKET Size: "; std::cerr << getRsItemSize(data) << " ID: "; - std::cerr << std::hex << failedtype << std::dec; + std::cerr << std::hex << failedtype << std::endl; std::cerr << "RsSerialiser::deserialise() FAILED PACKET: "; std::cerr << " Version: " << std::hex << (uint32_t) getRsItemVersion(failedtype) << std::dec; std::cerr << " Class: " << std::hex << (uint32_t) getRsItemClass(failedtype) << std::dec; diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index db765e36b..6670a377b 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -32,10 +32,11 @@ class RsSerializer: public RsSerialType /*! create_item * should be overloaded to create the correct type of item depending on the data */ - virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const - { - return NULL ; - } + virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const=0; + // { + // std::cerr << "(EE) Serializer does not overload create_item(). This is probably an error."<< std::endl; + // return NULL ; + // } // The following functions overload RsSerialType. They *should not* need to be further overloaded. diff --git a/libretroshare/src/services/p3msgservice.h b/libretroshare/src/services/p3msgservice.h index a36486514..2b7370d06 100644 --- a/libretroshare/src/services/p3msgservice.h +++ b/libretroshare/src/services/p3msgservice.h @@ -40,7 +40,7 @@ #include "pqi/p3cfgmgr.h" #include "services/p3service.h" -#include "serialiser/rsmsgitems.h" +#include "rsitems/rsmsgitems.h" #include "util/rsthreads.h" #include "retroshare/rsgxsifacetypes.h" From 26e95416d14430c8230ddde4b5fd8357e998f213 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 11:06:51 +0200 Subject: [PATCH 39/94] moved RTT items to rsitems/ --- libretroshare/src/libretroshare.pro | 4 ++-- libretroshare/src/{serialiser => rsitems}/rsrttitems.cc | 4 +--- libretroshare/src/{serialiser => rsitems}/rsrttitems.h | 0 libretroshare/src/serialization/rsserializer.h | 4 ---- libretroshare/src/services/p3rtt.cc | 2 +- libretroshare/src/services/p3rtt.h | 2 +- 6 files changed, 5 insertions(+), 11 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsrttitems.cc (98%) rename libretroshare/src/{serialiser => rsitems}/rsrttitems.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 4d94f4c71..e6f1a4ef4 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -483,7 +483,7 @@ HEADERS += rsitems/itempriorities.h \ rsitems/rsbwctrlitems.h \ rsitems/rsdiscovery2items.h \ serialiser/rsheartbeatitems.h \ - serialiser/rsrttitems.h \ + rsitems/rsrttitems.h \ serialiser/rsgxsrecognitems.h \ serialiser/rsgxsupdateitems.h \ serialiser/rsserviceinfoitems.h \ @@ -631,7 +631,7 @@ SOURCES += serialiser/rsbaseserial.cc \ rsitems/rsbwctrlitems.cc \ rsitems/rsdiscovery2items.cc \ serialiser/rsheartbeatitems.cc \ - serialiser/rsrttitems.cc \ + rsitems/rsrttitems.cc \ serialiser/rsgxsrecognitems.cc \ serialiser/rsgxsupdateitems.cc \ serialiser/rsserviceinfoitems.cc \ diff --git a/libretroshare/src/serialiser/rsrttitems.cc b/libretroshare/src/rsitems/rsrttitems.cc similarity index 98% rename from libretroshare/src/serialiser/rsrttitems.cc rename to libretroshare/src/rsitems/rsrttitems.cc index 5965f1068..ce2423dd4 100644 --- a/libretroshare/src/serialiser/rsrttitems.cc +++ b/libretroshare/src/rsitems/rsrttitems.cc @@ -24,9 +24,7 @@ * */ -#include "serialiser/rsbaseserial.h" -#include "serialiser/rsrttitems.h" -//#include "serialiser/rstlvbase.h" +#include "rsitems/rsrttitems.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/serialiser/rsrttitems.h b/libretroshare/src/rsitems/rsrttitems.h similarity index 100% rename from libretroshare/src/serialiser/rsrttitems.h rename to libretroshare/src/rsitems/rsrttitems.h diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 6670a377b..92f409361 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -33,10 +33,6 @@ class RsSerializer: public RsSerialType * should be overloaded to create the correct type of item depending on the data */ virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const=0; - // { - // std::cerr << "(EE) Serializer does not overload create_item(). This is probably an error."<< std::endl; - // return NULL ; - // } // The following functions overload RsSerialType. They *should not* need to be further overloaded. diff --git a/libretroshare/src/services/p3rtt.cc b/libretroshare/src/services/p3rtt.cc index 987467b77..8d4b2700b 100644 --- a/libretroshare/src/services/p3rtt.cc +++ b/libretroshare/src/services/p3rtt.cc @@ -32,7 +32,7 @@ #include "pqi/p3linkmgr.h" #include "services/p3rtt.h" -#include "serialiser/rsrttitems.h" +#include "rsitems/rsrttitems.h" #include diff --git a/libretroshare/src/services/p3rtt.h b/libretroshare/src/services/p3rtt.h index 9b881fba8..8714e2e02 100644 --- a/libretroshare/src/services/p3rtt.h +++ b/libretroshare/src/services/p3rtt.h @@ -30,7 +30,7 @@ #include #include -#include "serialiser/rsrttitems.h" +#include "rsitems/rsrttitems.h" #include "services/p3service.h" #include "retroshare/rsrtt.h" From 976a80a7af810f8f9583df617dd2e34200c61773 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 13:30:18 +0200 Subject: [PATCH 40/94] switch rsfilelistitems to new serialization --- .../src/file_sharing/rsfilelistitems.cc | 45 ++++++++++++++++--- .../src/file_sharing/rsfilelistitems.h | 34 ++++---------- 2 files changed, 47 insertions(+), 32 deletions(-) diff --git a/libretroshare/src/file_sharing/rsfilelistitems.cc b/libretroshare/src/file_sharing/rsfilelistitems.cc index 800f2f3d8..254d89edd 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.cc +++ b/libretroshare/src/file_sharing/rsfilelistitems.cc @@ -26,6 +26,41 @@ #include "file_sharing/rsfilelistitems.h" +void RsFileListsSyncRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,entry_hash,"entry_hash") ; + RsTypeSerializer::serial_process(j,ctx,flags ,"flags") ; + RsTypeSerializer::serial_process(j,ctx,last_known_recurs_modf_TS,"last_known_recurs_modf_TS") ; + RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; +} +void RsFileListsSyncResponseItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,entry_hash,"entry_hash") ; + RsTypeSerializer::serial_process (j,ctx,checksum,"checksum") ; + RsTypeSerializer::serial_process (j,ctx,flags ,"flags") ; + RsTypeSerializer::serial_process (j,ctx,last_known_recurs_modf_TS,"last_known_recurs_modf_TS") ; + RsTypeSerializer::serial_process (j,ctx,request_id,"request_id") ; + RsTypeSerializer::serial_process(j,ctx,directory_content_data,"directory_content_data") ; +} + +RsItem *RsFileListsSerialiser::create_item(uint16_t service,uint8_t type) const +{ + if(service != RS_SERVICE_TYPE_FILE_DATABASE) + return NULL ; + + switch(type) + { + case RS_PKT_SUBTYPE_FILELISTS_SYNC_REQ_ITEM: return new RsFileListsSyncRequestItem(); + case RS_PKT_SUBTYPE_FILELISTS_SYNC_RSP_ITEM: return new RsFileListsSyncResponseItem(); + default: + return NULL ; + } +} +void RsFileListsSyncResponseItem::clear() +{ + directory_content_data.TlvClear(); +} +#ifdef TO_REMOVE RsItem* RsFileListsSerialiser::deserialise(void *data, uint32_t *size) { #ifdef RSSERIAL_DEBUG @@ -325,13 +360,7 @@ uint32_t RsFileListsSyncResponseItem::serial_size()const return s; } -void RsFileListsSyncRequestItem::clear() -{ -} -void RsFileListsSyncResponseItem::clear() -{ - directory_content_data.TlvClear(); -} + std::ostream& RsFileListsSyncRequestItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsFileListsSyncReqItem", indent); @@ -363,3 +392,5 @@ std::ostream& RsFileListsSyncResponseItem::print(std::ostream &out, uint16_t ind return out; } + +#endif diff --git a/libretroshare/src/file_sharing/rsfilelistitems.h b/libretroshare/src/file_sharing/rsfilelistitems.h index d56827527..fd9a928d5 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.h +++ b/libretroshare/src/file_sharing/rsfilelistitems.h @@ -34,6 +34,8 @@ #include "serialiser/rstlvkeys.h" #include "gxs/rsgxsdata.h" +#include "serialization/rsserializer.h" + // These items have "flag type" numbers, but this is not used. const uint8_t RS_PKT_SUBTYPE_FILELISTS_SYNC_REQ_ITEM = 0x01; @@ -54,12 +56,7 @@ public: } virtual ~RsFileListsItem(){} - virtual bool serialise(void *data,uint32_t& size) const = 0 ; - virtual uint32_t serial_size() const = 0 ; virtual void clear() = 0; - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0) = 0; - - bool serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const; static const uint32_t FLAGS_SYNC_REQUEST = 0x0001 ; static const uint32_t FLAGS_SYNC_RESPONSE = 0x0002 ; @@ -79,12 +76,10 @@ public: RsFileListsSyncRequestItem() : RsFileListsItem(RS_PKT_SUBTYPE_FILELISTS_SYNC_REQ_ITEM) {} - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); + virtual void clear(){} + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const ; - RsFileHash entry_hash ; // hash of the directory to sync uint32_t flags; // used to say that it's a request or a response, say that the directory has been removed, ask for further update, etc. uint32_t last_known_recurs_modf_TS; // time of last modification, computed over all files+directories below. @@ -98,10 +93,8 @@ public: RsFileListsSyncResponseItem() : RsFileListsItem(RS_PKT_SUBTYPE_FILELISTS_SYNC_RSP_ITEM) {} virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const ; + virtual void serial_process(SerializeJob j,SerializeContext& ctx); RsFileHash entry_hash ; // hash of the directory to sync RsFileHash checksum ; // checksum of the bindary data, for checking @@ -112,24 +105,15 @@ public: RsTlvBinaryData directory_content_data ; // encoded binary data. This allows to vary the encoding format, in a way that is transparent to the serialiser. }; -class RsFileListsSerialiser : public RsSerialType +class RsFileListsSerialiser : public RsSerializer { public: - RsFileListsSerialiser() : RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_FILE_DATABASE) {} + RsFileListsSerialiser() : RsSerializer(RS_SERVICE_TYPE_FILE_DATABASE) {} virtual ~RsFileListsSerialiser() {} - virtual uint32_t size(RsItem *item); - virtual bool serialise(RsItem *item, void *data, uint32_t *size); - virtual RsItem* deserialise(void *data, uint32_t *size); - -private: - RsFileListsSyncRequestItem *deserialFileListsSyncRequestItem(void *data, uint32_t *size); /* RS_PKT_SUBTYPE_SYNC_GRP */ - RsFileListsSyncResponseItem *deserialFileListsSyncResponseItem(void *data, uint32_t *size); /* RS_PKT_SUBTYPE_SYNC_GRP */ -// RsFileListsSyncResponseItem *deserialFileListsConfigItem (void *data, uint32_t *size); /* RS_PKT_SUBTYPE_SYNC_GRP */ - - bool checkItemHeader(void *data, uint32_t *size, uint8_t subservice_type); + virtual RsItem *create_item(uint16_t service,uint8_t type) const ; }; From dc2df071a57c14314614c35e8b01de97e6e289e6 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 14:14:34 +0200 Subject: [PATCH 41/94] renamed RsSerializer into RsServiceSerializer --- libretroshare/src/chat/distributedchat.cc | 8 +- libretroshare/src/chat/rschatitems.cc | 2 +- libretroshare/src/chat/rschatitems.h | 4 +- .../src/file_sharing/rsfilelistitems.cc | 334 ------------------ .../src/file_sharing/rsfilelistitems.h | 4 +- libretroshare/src/ft/ftserver.cc | 2 +- libretroshare/src/ft/ftserver.h | 4 +- libretroshare/src/rsitems/rsbanlistitems.h | 4 +- libretroshare/src/rsitems/rsbwctrlitems.h | 4 +- libretroshare/src/rsitems/rsdiscovery2items.h | 4 +- .../src/rsitems/rsfiletransferitems.h | 4 +- .../src/rsitems/rsgxsreputationitems.h | 4 +- libretroshare/src/rsitems/rsmsgitems.cc | 2 +- libretroshare/src/rsitems/rsmsgitems.h | 4 +- libretroshare/src/rsitems/rsrttitems.h | 4 +- .../src/serialization/rsserializer.cc | 14 +- .../src/serialization/rsserializer.h | 4 +- libretroshare/src/services/p3msgservice.cc | 8 +- libretroshare/src/turtle/rsturtleitem.h | 4 +- .../src/turtle/turtleclientservice.h | 2 +- 20 files changed, 43 insertions(+), 377 deletions(-) diff --git a/libretroshare/src/chat/distributedchat.cc b/libretroshare/src/chat/distributedchat.cc index 79c41b2f2..696ce3058 100644 --- a/libretroshare/src/chat/distributedchat.cc +++ b/libretroshare/src/chat/distributedchat.cc @@ -222,7 +222,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const mGixs->requestKey(obj->signature.keyId,peer_list,RsIdentityUsage(RS_SERVICE_TYPE_CHAT,RsIdentityUsage::CHAT_LOBBY_MSG_VALIDATION,RsGxsGroupId(),RsGxsMessageId(),obj->lobby_id)); - uint32_t size = RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).size(dynamic_cast(obj)) ; + uint32_t size = RsChatSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_SIGNATURE).size(dynamic_cast(obj)) ; RsTemporaryMemory memory(size) ; #ifdef DEBUG_CHAT_LOBBIES @@ -230,7 +230,7 @@ bool DistributedChatService::checkSignature(RsChatLobbyBouncingObject *obj,const std::cerr << " signature id: " << obj->signature.keyId << std::endl; #endif - if(!RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise(dynamic_cast(obj),memory,&size)) + if(!RsChatSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise(dynamic_cast(obj),memory,&size)) { std::cerr << " (EE) Cannot serialise message item. " << std::endl; return false ; @@ -970,10 +970,10 @@ bool DistributedChatService::locked_initLobbyBouncableObject(const ChatLobbyId& // now sign the object, if the lobby expects it - uint32_t size = RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).size(dynamic_cast(&item)) ; + uint32_t size = RsChatSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_SIGNATURE).size(dynamic_cast(&item)) ; RsTemporaryMemory memory(size) ; - if(!RsChatSerialiser(RsSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise(dynamic_cast(&item),memory,&size)) + if(!RsChatSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_SIGNATURE).serialise(dynamic_cast(&item),memory,&size)) { std::cerr << "(EE) Cannot sign message item. " << std::endl; return false ; diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index e30c401c1..7aa0dd4f3 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -86,7 +86,7 @@ void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, Serialize RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_NAME,nick,"nick") ; - if(!(ctx.mFlags & RsSerializer::SERIALIZATION_FLAG_SIGNATURE)) + if(!(ctx.mFlags & RsServiceSerializer::SERIALIZATION_FLAG_SIGNATURE)) RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; } diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index b357f0873..1766dbfec 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -321,11 +321,11 @@ class RsChatAvatarItem: public RsChatItem unsigned char *image_data ; // image }; -class RsChatSerialiser: public RsSerializer +class RsChatSerialiser: public RsServiceSerializer { public: RsChatSerialiser(SerializationFlags flags = SERIALIZATION_FLAG_NONE) - :RsSerializer(RS_SERVICE_TYPE_CHAT,SerializeContext::FORMAT_BINARY,flags) {} + :RsServiceSerializer(RS_SERVICE_TYPE_CHAT,SerializeContext::FORMAT_BINARY,flags) {} virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) const ; }; diff --git a/libretroshare/src/file_sharing/rsfilelistitems.cc b/libretroshare/src/file_sharing/rsfilelistitems.cc index 254d89edd..85a94488f 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.cc +++ b/libretroshare/src/file_sharing/rsfilelistitems.cc @@ -60,337 +60,3 @@ void RsFileListsSyncResponseItem::clear() { directory_content_data.TlvClear(); } -#ifdef TO_REMOVE -RsItem* RsFileListsSerialiser::deserialise(void *data, uint32_t *size) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (getRsItemService(rstype) != RS_SERVICE_TYPE_FILE_DATABASE)) - return NULL; /* wrong type */ - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_FILELISTS_SYNC_REQ_ITEM: return deserialFileListsSyncRequestItem(data, size); - case RS_PKT_SUBTYPE_FILELISTS_SYNC_RSP_ITEM: return deserialFileListsSyncResponseItem(data, size); -// case RS_PKT_SUBTYPE_FILELISTS_CONFIG_ITEM: return deserialFileListsConfigItem (data, size); - - default: - { - std::cerr << "(WW) RsFileListsSerialiser::deserialise() : unhandled item type " << getRsItemSubType(rstype) << std::endl; - return NULL; - - } - } -} - -uint32_t RsFileListsSerialiser::size(RsItem *item) -{ - RsFileListsItem *flst_item = dynamic_cast(item) ; - - if(flst_item != NULL) - return flst_item->serial_size() ; - else - { - std::cerr << "RsFileListsSerialiser::serialise(): Not an RsFileListsItem!" << std::endl; - return 0; - } -} - -bool RsFileListsSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ - RsFileListsItem *flst_item = dynamic_cast(item) ; - - if(flst_item != NULL) - return flst_item->serialise(data,*size) ; - else - { - std::cerr << "RsFileListsSerialiser::serialise(): Not an RsFileListsItem!" << std::endl; - return 0; - } -} - -bool RsFileListsItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const -{ - tlvsize = serial_size() ; - offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsFileTransferItem::serialise_header(): ERROR. Not enough size!" << std::endl; - return false ; - } -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileItemSerialiser::serialiseData() Header: " << ok << std::endl; -#endif - offset += 8; - - return true ; -} - -bool RsFileListsSyncRequestItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::serialiseFileListsSyncReqItem()" << std::endl; -#endif - - /* RsFileListsSyncMsgItem */ - - ok &= entry_hash.serialise(data, size, offset); - ok &= setRawUInt32(data, size, &offset, flags ); - ok &= setRawUInt32(data, size, &offset, last_known_recurs_modf_TS); - ok &= setRawUInt64(data, size, &offset, request_id); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::serialiseNxsSynMsgItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsFileListsSerialiser::serialiseNxsSynMsgItem() NOK" << std::endl; - } -#endif - - return ok; -} - -bool RsFileListsSyncResponseItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::serialiseFileListsSyncReqItem()" << std::endl; -#endif - - /* RsFileListsSyncMsgItem */ - - ok &= entry_hash.serialise(data, size, offset); - ok &= checksum.serialise(data, size, offset); - ok &= setRawUInt32(data, size, &offset, flags ); - ok &= setRawUInt32(data, size, &offset, last_known_recurs_modf_TS); - ok &= setRawUInt64(data, size, &offset, request_id); - ok &= directory_content_data.SetTlv(data,size,&offset) ; - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::serialiseNxsSynMsgItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsFileListsSerialiser::serialiseNxsSynMsgItem() NOK" << std::endl; - } -#endif - - return ok; -} - -//============================================================================================================================// -// Deserialisation // -//============================================================================================================================// - -//RsFileListsConfigItem* RsFileListsSerialiser::deserialFileListsConfigItem(void *data, uint32_t *size) -//{ -// NOT_IMPLEMENTED(); -// -// return NULL ; -//} - -RsFileListsSyncRequestItem* RsFileListsSerialiser::deserialFileListsSyncRequestItem(void *data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_FILELISTS_SYNC_REQ_ITEM); - uint32_t offset = 8; - - RsFileListsSyncRequestItem* item = new RsFileListsSyncRequestItem(); - - ok &= item->entry_hash.deserialise(data, *size, offset); - ok &= getRawUInt32(data, *size, &offset, &item->flags); - ok &= getRawUInt32(data, *size, &offset, &item->last_known_recurs_modf_TS); - ok &= getRawUInt64(data, *size, &offset, &item->request_id); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::deserialNxsGrp() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::deserialNxsGrp() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} -RsFileListsSyncResponseItem* RsFileListsSerialiser::deserialFileListsSyncResponseItem(void *data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_FILELISTS_SYNC_RSP_ITEM); - uint32_t offset = 8; - - RsFileListsSyncResponseItem* item = new RsFileListsSyncResponseItem(); - - /* - uint32_t entry_index ; // index of the directory to sync - uint32_t flags; // used to say that it's a request or a response, say that the directory has been removed, ask for further update, etc. - uint32_t last_known_recurs_modf_TS; // time of last modification, computed over all files+directories below. - uint64_t request_id; // use to determine if changes that have occured since last hash - */ - - ok &= item->entry_hash.deserialise(data, *size, offset); - ok &= item->checksum.deserialise(data, *size, offset); - ok &= getRawUInt32(data, *size, &offset, &item->flags); - ok &= getRawUInt32(data, *size, &offset, &item->last_known_recurs_modf_TS); - ok &= getRawUInt64(data, *size, &offset, &item->request_id); - - ok &= item->directory_content_data.GetTlv(data,*size,&offset) ; - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::deserialNxsGrp() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::deserialNxsGrp() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} -bool RsFileListsSerialiser::checkItemHeader(void *data,uint32_t *size,uint8_t subservice_type) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::checkItemHeader()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_FILE_DATABASE != getRsItemService(rstype)) || (subservice_type != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::checkItemHeader() FAIL wrong type" << std::endl; -#endif - return false; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileListsSerialiser::checkItemHeader() FAIL wrong size" << std::endl; -#endif - return false; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - return true ; -} - -//============================================================================================================================// -// Sizes // -//============================================================================================================================// - -uint32_t RsFileListsSyncRequestItem::serial_size()const -{ - - uint32_t s = 8; //header size - - s += RsFileHash::serial_size(); // entry hash - s += 4; // flags - s += 4; // last_known_recurs_modf_TS - s += 8; // request_id - - return s; -} - -uint32_t RsFileListsSyncResponseItem::serial_size()const -{ - - uint32_t s = 8; //header size - - s += RsFileHash::serial_size(); // entry hash - s += RsFileHash::serial_size(); // checksum - s += 4; // flags - s += 4; // last_known_recurs_modf_TS - s += 8; // request_id - s += directory_content_data.TlvSize(); - - return s; -} - - -std::ostream& RsFileListsSyncRequestItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileListsSyncReqItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out , int_Indent); out << "Entry hash: " << entry_hash << std::endl; - printIndent(out , int_Indent); out << "Flags: " << (uint32_t) flags << std::endl; - printIndent(out , int_Indent); out << "Last modf TS: " << last_known_recurs_modf_TS << std::endl; - printIndent(out , int_Indent); out << "request id: " << std::hex << request_id << std::dec << std::endl; - - printRsItemEnd(out ,"RsFileListsSyncReqItem", indent); - - return out; -} - -std::ostream& RsFileListsSyncResponseItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileListsSyncDirItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out , int_Indent); out << "Entry hash: " << entry_hash << std::endl; - printIndent(out , int_Indent); out << "Checksum : " << checksum << std::endl; - printIndent(out , int_Indent); out << "Flags: " << (uint32_t) flags << std::endl; - printIndent(out , int_Indent); out << "Last modf TS: " << last_known_recurs_modf_TS << std::endl; - printIndent(out , int_Indent); out << "request id: " << std::hex << request_id << std::dec << std::endl; - printIndent(out , int_Indent); out << "Data size: " << directory_content_data.bin_len << std::endl; - - printRsItemEnd(out ,"RsFileListsSyncDirItem", indent); - - return out; -} - -#endif diff --git a/libretroshare/src/file_sharing/rsfilelistitems.h b/libretroshare/src/file_sharing/rsfilelistitems.h index fd9a928d5..391d3dd88 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.h +++ b/libretroshare/src/file_sharing/rsfilelistitems.h @@ -105,11 +105,11 @@ public: RsTlvBinaryData directory_content_data ; // encoded binary data. This allows to vary the encoding format, in a way that is transparent to the serialiser. }; -class RsFileListsSerialiser : public RsSerializer +class RsFileListsSerialiser : public RsServiceSerializer { public: - RsFileListsSerialiser() : RsSerializer(RS_SERVICE_TYPE_FILE_DATABASE) {} + RsFileListsSerialiser() : RsServiceSerializer(RS_SERVICE_TYPE_FILE_DATABASE) {} virtual ~RsFileListsSerialiser() {} diff --git a/libretroshare/src/ft/ftserver.cc b/libretroshare/src/ft/ftserver.cc index 9dcc139d4..15a44f34f 100644 --- a/libretroshare/src/ft/ftserver.cc +++ b/libretroshare/src/ft/ftserver.cc @@ -64,7 +64,7 @@ static const time_t FILE_TRANSFER_LOW_PRIORITY_TASKS_PERIOD = 5 ; // low priorit /* Setup */ ftServer::ftServer(p3PeerMgr *pm, p3ServiceControl *sc) - : p3Service(),RsSerializer(RS_SERVICE_TYPE_TURTLE), // should be FT, but this is for backward compatibility + : p3Service(),RsServiceSerializer(RS_SERVICE_TYPE_TURTLE), // should be FT, but this is for backward compatibility mPeerMgr(pm), mServiceCtrl(sc), mFileDatabase(NULL), mFtController(NULL), mFtExtra(NULL), diff --git a/libretroshare/src/ft/ftserver.h b/libretroshare/src/ft/ftserver.h index 23606b28e..5ad4824b5 100644 --- a/libretroshare/src/ft/ftserver.h +++ b/libretroshare/src/ft/ftserver.h @@ -68,7 +68,7 @@ class p3PeerMgr; class p3ServiceControl; class p3FileDatabase; -class ftServer: public p3Service, public RsFiles, public ftDataSend, public RsTurtleClientService, public RsSerializer +class ftServer: public p3Service, public RsFiles, public ftDataSend, public RsTurtleClientService, public RsServiceSerializer { public: @@ -98,7 +98,7 @@ public: virtual bool handleTunnelRequest(const RsFileHash& hash,const RsPeerId& peer_id) ; virtual void receiveTurtleData(RsTurtleGenericTunnelItem *item,const RsFileHash& hash,const RsPeerId& virtual_peer_id,RsTurtleGenericTunnelItem::Direction direction) ; virtual RsItem *create_item(uint16_t service,uint8_t item_type) const ; - virtual RsSerializer *serializer() { return this ; } + virtual RsServiceSerializer *serializer() { return this ; } void addVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&,RsTurtleGenericTunnelItem::Direction dir) ; void removeVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&) ; diff --git a/libretroshare/src/rsitems/rsbanlistitems.h b/libretroshare/src/rsitems/rsbanlistitems.h index cc3f96eeb..3fce37956 100644 --- a/libretroshare/src/rsitems/rsbanlistitems.h +++ b/libretroshare/src/rsitems/rsbanlistitems.h @@ -72,10 +72,10 @@ public: RsTlvBanList banned_peers; }; -class RsBanListSerialiser: public RsSerializer +class RsBanListSerialiser: public RsServiceSerializer { public: - RsBanListSerialiser() :RsSerializer(RS_SERVICE_TYPE_BANLIST) {} + RsBanListSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_BANLIST) {} virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) const ; }; diff --git a/libretroshare/src/rsitems/rsbwctrlitems.h b/libretroshare/src/rsitems/rsbwctrlitems.h index e9262cd5b..e21410b39 100644 --- a/libretroshare/src/rsitems/rsbwctrlitems.h +++ b/libretroshare/src/rsitems/rsbwctrlitems.h @@ -57,10 +57,10 @@ public: }; -class RsBwCtrlSerialiser: public RsSerializer +class RsBwCtrlSerialiser: public RsServiceSerializer { public: - RsBwCtrlSerialiser() :RsSerializer(RS_SERVICE_TYPE_BWCTRL) {} + RsBwCtrlSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_BWCTRL) {} virtual ~RsBwCtrlSerialiser() {} RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const; diff --git a/libretroshare/src/rsitems/rsdiscovery2items.h b/libretroshare/src/rsitems/rsdiscovery2items.h index fc1a944cb..7610d534f 100644 --- a/libretroshare/src/rsitems/rsdiscovery2items.h +++ b/libretroshare/src/rsitems/rsdiscovery2items.h @@ -166,10 +166,10 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); #endif -class RsDiscSerialiser: public RsSerializer +class RsDiscSerialiser: public RsServiceSerializer { public: - RsDiscSerialiser() :RsSerializer(RS_SERVICE_TYPE_DISC) {} + RsDiscSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_DISC) {} virtual ~RsDiscSerialiser() {} diff --git a/libretroshare/src/rsitems/rsfiletransferitems.h b/libretroshare/src/rsitems/rsfiletransferitems.h index 5cfed03b9..b51e74d53 100644 --- a/libretroshare/src/rsitems/rsfiletransferitems.h +++ b/libretroshare/src/rsitems/rsfiletransferitems.h @@ -176,10 +176,10 @@ class RsFileTransferSingleChunkCrcItem: public RsFileTransferItem /**************************************************************************/ -class RsFileTransferSerialiser: public RsSerializer +class RsFileTransferSerialiser: public RsServiceSerializer { public: - RsFileTransferSerialiser(): RsSerializer(RS_SERVICE_TYPE_FILE_TRANSFER) {} + RsFileTransferSerialiser(): RsServiceSerializer(RS_SERVICE_TYPE_FILE_TRANSFER) {} virtual ~RsFileTransferSerialiser() {} diff --git a/libretroshare/src/rsitems/rsgxsreputationitems.h b/libretroshare/src/rsitems/rsgxsreputationitems.h index cc3f64a78..1f30a5d65 100644 --- a/libretroshare/src/rsitems/rsgxsreputationitems.h +++ b/libretroshare/src/rsitems/rsgxsreputationitems.h @@ -163,10 +163,10 @@ public: }; -class RsGxsReputationSerialiser: public RsSerializer +class RsGxsReputationSerialiser: public RsServiceSerializer { public: - RsGxsReputationSerialiser() :RsSerializer(RS_SERVICE_GXS_TYPE_REPUTATION){} + RsGxsReputationSerialiser() :RsServiceSerializer(RS_SERVICE_GXS_TYPE_REPUTATION){} virtual ~RsGxsReputationSerialiser(){} virtual RsItem *create_item(uint16_t service,uint8_t item_type) const; diff --git a/libretroshare/src/rsitems/rsmsgitems.cc b/libretroshare/src/rsitems/rsmsgitems.cc index 7405f37e0..8fd2f2c55 100644 --- a/libretroshare/src/rsitems/rsmsgitems.cc +++ b/libretroshare/src/rsitems/rsmsgitems.cc @@ -158,7 +158,7 @@ void RsMsgItem::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process(j,ctx,attachment,"attachment"); - if(ctx.mFlags & RsSerializer::SERIALIZATION_FLAG_CONFIG) + if(ctx.mFlags & RsServiceSerializer::SERIALIZATION_FLAG_CONFIG) RsTypeSerializer::serial_process(j,ctx,msgId,"msgId"); } diff --git a/libretroshare/src/rsitems/rsmsgitems.h b/libretroshare/src/rsitems/rsmsgitems.h index 5eb94e5b4..f0916352b 100644 --- a/libretroshare/src/rsitems/rsmsgitems.h +++ b/libretroshare/src/rsitems/rsmsgitems.h @@ -235,11 +235,11 @@ class RsMsgParentId : public RsMessageItem uint32_t msgParentId; }; -class RsMsgSerialiser: public RsSerializer +class RsMsgSerialiser: public RsServiceSerializer { public: RsMsgSerialiser(SerializationFlags flags) - :RsSerializer(RS_SERVICE_TYPE_MSG,SerializeContext::FORMAT_BINARY,flags){} + :RsServiceSerializer(RS_SERVICE_TYPE_MSG,SerializeContext::FORMAT_BINARY,flags){} virtual ~RsMsgSerialiser() {} diff --git a/libretroshare/src/rsitems/rsrttitems.h b/libretroshare/src/rsitems/rsrttitems.h index cad02062e..b3e5bdec2 100644 --- a/libretroshare/src/rsitems/rsrttitems.h +++ b/libretroshare/src/rsitems/rsrttitems.h @@ -78,10 +78,10 @@ class RsRttPongItem: public RsRttItem }; -class RsRttSerialiser: public RsSerializer +class RsRttSerialiser: public RsServiceSerializer { public: - RsRttSerialiser() :RsSerializer(RS_SERVICE_TYPE_RTT) {} + RsRttSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_RTT) {} virtual ~RsRttSerialiser(){} diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index 85a7a9430..0a468abf5 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -2,11 +2,11 @@ #include "serialization/rsserializer.h" #include "serialization/rstypeserializer.h" -const SerializationFlags RsSerializer::SERIALIZATION_FLAG_NONE ( 0x0000 ); -const SerializationFlags RsSerializer::SERIALIZATION_FLAG_CONFIG ( 0x0001 ); -const SerializationFlags RsSerializer::SERIALIZATION_FLAG_SIGNATURE ( 0x0002 ); +const SerializationFlags RsServiceSerializer::SERIALIZATION_FLAG_NONE ( 0x0000 ); +const SerializationFlags RsServiceSerializer::SERIALIZATION_FLAG_CONFIG ( 0x0001 ); +const SerializationFlags RsServiceSerializer::SERIALIZATION_FLAG_SIGNATURE ( 0x0002 ); -RsItem *RsSerializer::deserialise(void *data, uint32_t *size) +RsItem *RsServiceSerializer::deserialise(void *data, uint32_t *size) { uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; @@ -37,7 +37,7 @@ RsItem *RsSerializer::deserialise(void *data, uint32_t *size) return NULL ; } -bool RsSerializer::serialise(RsItem *item,void *data,uint32_t *size) +bool RsServiceSerializer::serialise(RsItem *item,void *data,uint32_t *size) { SerializeContext ctx(static_cast(data),0,mFormat,mFlags); @@ -64,7 +64,7 @@ bool RsSerializer::serialise(RsItem *item,void *data,uint32_t *size) return true ; } -uint32_t RsSerializer::size(RsItem *item) +uint32_t RsServiceSerializer::size(RsItem *item) { SerializeContext ctx(NULL,0,mFormat,mFlags); @@ -74,7 +74,7 @@ uint32_t RsSerializer::size(RsItem *item) return ctx.mOffset ; } -void RsSerializer::print(RsItem *item) +void RsServiceSerializer::print(RsItem *item) { SerializeContext ctx(NULL,0,mFormat,mFlags); diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 92f409361..60860b426 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -10,7 +10,7 @@ #define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " -class RsSerializer: public RsSerialType +class RsServiceSerializer: public RsSerialType { public: // These are convenience flags to be used by the items when processing the data. The names of the flags @@ -23,7 +23,7 @@ class RsSerializer: public RsSerialType static const SerializationFlags SERIALIZATION_FLAG_CONFIG ; // 0x0001 static const SerializationFlags SERIALIZATION_FLAG_SIGNATURE ; // 0x0002 - RsSerializer(uint16_t service_id, + RsServiceSerializer(uint16_t service_id, SerializeContext::SerializationFormat format = SerializeContext::FORMAT_BINARY, SerializationFlags flags = SERIALIZATION_FLAG_NONE) diff --git a/libretroshare/src/services/p3msgservice.cc b/libretroshare/src/services/p3msgservice.cc index 44c244023..a3aacfc7b 100644 --- a/libretroshare/src/services/p3msgservice.cc +++ b/libretroshare/src/services/p3msgservice.cc @@ -86,7 +86,7 @@ static const uint32_t RS_MSG_DISTANT_MESSAGE_HASH_KEEP_TIME = 2*30*86400 ; // ke p3MsgService::p3MsgService(p3ServiceControl *sc, p3IdService *id_serv) :p3Service(), p3Config(), mIdService(id_serv), mServiceCtrl(sc), mMsgMtx("p3MsgService"), mMsgUniqueId(0) { - _serialiser = new RsMsgSerialiser(RsSerializer::SERIALIZATION_FLAG_NONE); // this serialiser is used for services. It's not the same than the one returned by setupSerialiser(). We need both!! + _serialiser = new RsMsgSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_NONE); // this serialiser is used for services. It's not the same than the one returned by setupSerialiser(). We need both!! addSerialType(_serialiser); mMsgUniqueId = 1 ; // MsgIds are not transmitted, but only used locally as a storage index. As such, thay do not need to be different @@ -519,7 +519,7 @@ RsSerialiser* p3MsgService::setupSerialiser() // this serialiser is used for con { RsSerialiser *rss = new RsSerialiser ; - rss->addSerialType(new RsMsgSerialiser(RsSerializer::SERIALIZATION_FLAG_CONFIG)); + rss->addSerialType(new RsMsgSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_CONFIG)); rss->addSerialType(new RsGeneralConfigSerialiser()); return rss; @@ -2024,10 +2024,10 @@ void p3MsgService::sendDistantMsgItem(RsMsgItem *msgitem) // The item is serialized and turned into a generic turtle item. Use use the explicit serialiser to make sure that the msgId is not included - uint32_t msg_serialized_rssize = RsMsgSerialiser(RsSerializer::SERIALIZATION_FLAG_NONE).size(msgitem) ; + uint32_t msg_serialized_rssize = RsMsgSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_NONE).size(msgitem) ; RsTemporaryMemory msg_serialized_data(msg_serialized_rssize) ; - if(!RsMsgSerialiser(RsSerializer::SERIALIZATION_FLAG_NONE).serialise(msgitem,msg_serialized_data,&msg_serialized_rssize)) + if(!RsMsgSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_NONE).serialise(msgitem,msg_serialized_data,&msg_serialized_rssize)) { std::cerr << "(EE) p3MsgService::sendTurtleData(): Serialization error." << std::endl; return ; diff --git a/libretroshare/src/turtle/rsturtleitem.h b/libretroshare/src/turtle/rsturtleitem.h index 0249cce22..9bc3fc4bf 100644 --- a/libretroshare/src/turtle/rsturtleitem.h +++ b/libretroshare/src/turtle/rsturtleitem.h @@ -205,10 +205,10 @@ class RsTurtleGenericDataItem: public RsTurtleGenericTunnelItem /* Turtle Serialiser class */ /***********************************************************************************/ -class RsTurtleSerialiser: public RsSerializer +class RsTurtleSerialiser: public RsServiceSerializer { public: - RsTurtleSerialiser() : RsSerializer(RS_SERVICE_TYPE_TURTLE) {} + RsTurtleSerialiser() : RsServiceSerializer(RS_SERVICE_TYPE_TURTLE) {} virtual RsItem *create_item(uint16_t service,uint8_t item_subtype) const; diff --git a/libretroshare/src/turtle/turtleclientservice.h b/libretroshare/src/turtle/turtleclientservice.h index 7fa4d8b18..d9552c662 100644 --- a/libretroshare/src/turtle/turtleclientservice.h +++ b/libretroshare/src/turtle/turtleclientservice.h @@ -76,7 +76,7 @@ class RsTurtleClientService // services might only use the generic item already provided by the turtle // router: RsTurtleGenericDataItem - virtual RsSerializer *serializer() { return NULL ; } + virtual RsServiceSerializer *serializer() { return NULL ; } // These methods are called by the turtle router to add/remove virtual peers when tunnels are created/deleted // From 8ae6541ceb4daea26e77ea7b2b41934980ca3893 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 17:10:01 +0200 Subject: [PATCH 42/94] added two new classes for config/service serialisers and a base generic serialiser class --- .../src/serialization/rsserializer.cc | 14 ++--- .../src/serialization/rsserializer.h | 52 +++++++++++++++---- 2 files changed, 50 insertions(+), 16 deletions(-) diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index 0a468abf5..9f14ee91e 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -2,11 +2,11 @@ #include "serialization/rsserializer.h" #include "serialization/rstypeserializer.h" -const SerializationFlags RsServiceSerializer::SERIALIZATION_FLAG_NONE ( 0x0000 ); -const SerializationFlags RsServiceSerializer::SERIALIZATION_FLAG_CONFIG ( 0x0001 ); -const SerializationFlags RsServiceSerializer::SERIALIZATION_FLAG_SIGNATURE ( 0x0002 ); +const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_NONE ( 0x0000 ); +const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_CONFIG ( 0x0001 ); +const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE ( 0x0002 ); -RsItem *RsServiceSerializer::deserialise(void *data, uint32_t *size) +RsItem *RsGenericSerializer::deserialise(void *data, uint32_t *size) { uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; @@ -37,7 +37,7 @@ RsItem *RsServiceSerializer::deserialise(void *data, uint32_t *size) return NULL ; } -bool RsServiceSerializer::serialise(RsItem *item,void *data,uint32_t *size) +bool RsGenericSerializer::serialise(RsItem *item,void *data,uint32_t *size) { SerializeContext ctx(static_cast(data),0,mFormat,mFlags); @@ -64,7 +64,7 @@ bool RsServiceSerializer::serialise(RsItem *item,void *data,uint32_t *size) return true ; } -uint32_t RsServiceSerializer::size(RsItem *item) +uint32_t RsGenericSerializer::size(RsItem *item) { SerializeContext ctx(NULL,0,mFormat,mFlags); @@ -74,7 +74,7 @@ uint32_t RsServiceSerializer::size(RsItem *item) return ctx.mOffset ; } -void RsServiceSerializer::print(RsItem *item) +void RsGenericSerializer::print(RsItem *item) { SerializeContext ctx(NULL,0,mFormat,mFlags); diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 60860b426..33e643215 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -10,9 +10,11 @@ #define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " -class RsServiceSerializer: public RsSerialType +class RsGenericSerializer: public RsSerialType { - public: +public: + + // These are convenience flags to be used by the items when processing the data. The names of the flags // are not very important. What matters is that the serial_process() method of each item correctly // deals with the data when it sees the flags, if the serialiser sets them. By default the flags are not @@ -23,13 +25,7 @@ class RsServiceSerializer: public RsSerialType static const SerializationFlags SERIALIZATION_FLAG_CONFIG ; // 0x0001 static const SerializationFlags SERIALIZATION_FLAG_SIGNATURE ; // 0x0002 - RsServiceSerializer(uint16_t service_id, - SerializeContext::SerializationFormat format = SerializeContext::FORMAT_BINARY, - SerializationFlags flags = SERIALIZATION_FLAG_NONE) - - : RsSerialType(RS_PKT_VERSION_SERVICE,service_id),mFormat(format),mFlags(flags) {} - - /*! create_item + /*! create_item * should be overloaded to create the correct type of item depending on the data */ virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const=0; @@ -41,10 +37,48 @@ class RsServiceSerializer: public RsSerialType uint32_t size(RsItem *item) ; void print(RsItem *item) ; +protected: + RsGenericSerializer(uint8_t serial_class, + uint8_t serial_type, + SerializeContext::SerializationFormat format, + SerializationFlags flags ) + : RsSerialType(RS_PKT_VERSION1,serial_class,serial_type), mFormat(format),mFlags(flags) + {} + + RsGenericSerializer(uint16_t service, + SerializeContext::SerializationFormat format, + SerializationFlags flags ) + : RsSerialType(RS_PKT_VERSION_SERVICE,service), mFormat(format),mFlags(flags) + {} + private: SerializeContext::SerializationFormat mFormat ; SerializationFlags mFlags ; + +}; + +class RsServiceSerializer: public RsGenericSerializer +{ +public: + RsServiceSerializer(uint16_t service_id, + SerializeContext::SerializationFormat format = SerializeContext::FORMAT_BINARY, + SerializationFlags flags = SERIALIZATION_FLAG_NONE) + + : RsGenericSerializer(service_id,format,flags) {} +}; + +class RsConfigSerializer: public RsGenericSerializer +{ +public: + RsConfigSerializer(uint8_t config_class, + uint8_t config_type, + SerializeContext::SerializationFormat format = SerializeContext::FORMAT_BINARY, + SerializationFlags flags = RsGenericSerializer::SERIALIZATION_FLAG_NONE) + + : RsGenericSerializer(config_class,config_type,format,flags) {} }; + + From af4fcf767902c19ff3cd2d4cbef5f60ac9157b7d Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 17:33:30 +0200 Subject: [PATCH 43/94] switched rshistoryitems to new serialization --- .../src/serialiser/rshistoryitems.cc | 35 ++++++++++++++++--- libretroshare/src/serialiser/rshistoryitems.h | 24 ++++++------- .../src/serialization/rsserializer.cc | 31 +++++++++++++++- .../src/serialization/rsserializer.h | 22 ++++++++---- 4 files changed, 85 insertions(+), 27 deletions(-) diff --git a/libretroshare/src/serialiser/rshistoryitems.cc b/libretroshare/src/serialiser/rshistoryitems.cc index 2ecbf591b..6c05e9afb 100644 --- a/libretroshare/src/serialiser/rshistoryitems.cc +++ b/libretroshare/src/serialiser/rshistoryitems.cc @@ -34,7 +34,31 @@ #include -/*************************************************************************/ +void RsHistoryMsgItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + uint16_t version=0; + + RsTypeSerializer::serial_process(j,ctx,version,"version") ; + RsTypeSerializer::serial_process (j,ctx,chatPeerId,"chatPeerId") ; + RsTypeSerializer::serial_process (j,ctx,incoming,"incoming") ; + RsTypeSerializer::serial_process (j,ctx,peerId,"peerId") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,peerName,"peerName") ; + RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; + RsTypeSerializer::serial_process(j,ctx,recvTime,"recvTime") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_MSG,message,"message") ; +} + +RsItem *RsHistorySerialiser::create_item(uint8_t serial_class,uint8_t serial_type) const +{ + if(serial_class != RS_PKT_CLASS_CONFIG) + return NULL ; + + if(serial_type == RS_PKT_SUBTYPE_DEFAULT) + return new RsHistoryMsgItem(); + + return NULL ; +} + RsHistoryMsgItem::RsHistoryMsgItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_HISTORY_CONFIG, RS_PKT_SUBTYPE_DEFAULT) { @@ -45,6 +69,9 @@ RsHistoryMsgItem::RsHistoryMsgItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONF saveToDisc = true; } +#ifdef TO_REMOVE + +/*************************************************************************/ RsHistoryMsgItem::~RsHistoryMsgItem() { } @@ -92,9 +119,6 @@ std::ostream& RsHistoryMsgItem::print(std::ostream &out, uint16_t indent) return out; } -RsHistorySerialiser::RsHistorySerialiser() : RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_HISTORY_CONFIG) -{ -} RsHistorySerialiser::~RsHistorySerialiser() { @@ -114,7 +138,6 @@ uint32_t RsHistorySerialiser::sizeHistoryMsgItem(RsHistoryMsgItem* item) return s; } - /* serialise the data to the buffer */ bool RsHistorySerialiser::serialiseHistoryMsgItem(RsHistoryMsgItem* item, void* data, uint32_t* pktsize) { @@ -266,3 +289,5 @@ RsItem* RsHistorySerialiser::deserialise(void *data, uint32_t *pktsize) } /*************************************************************************/ + +#endif diff --git a/libretroshare/src/serialiser/rshistoryitems.h b/libretroshare/src/serialiser/rshistoryitems.h index 72f186561..ffc5b571c 100644 --- a/libretroshare/src/serialiser/rshistoryitems.h +++ b/libretroshare/src/serialiser/rshistoryitems.h @@ -28,18 +28,21 @@ #include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" +#include "serialiser/rsconfigitems.h" #include "retroshare/rstypes.h" +#include "serialization/rsserializer.h" + /**************************************************************************/ class RsHistoryMsgItem: public RsItem { public: RsHistoryMsgItem(); - virtual ~RsHistoryMsgItem(); + virtual ~RsHistoryMsgItem() {} + virtual void clear() {} - virtual void clear(); - std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(SerializeJob j,SerializeContext& ctx); RsPeerId chatPeerId; // empty for global chat bool incoming; @@ -54,20 +57,13 @@ public: bool saveToDisc; }; -class RsHistorySerialiser: public RsSerialType +class RsHistorySerialiser: public RsConfigSerializer { public: - RsHistorySerialiser(); - virtual ~RsHistorySerialiser(); - - virtual uint32_t size(RsItem*); - virtual bool serialise(RsItem* item, void* data, uint32_t* size); - virtual RsItem* deserialise(void* data, uint32_t* size); + RsHistorySerialiser() : RsConfigSerializer(RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_HISTORY_CONFIG) {} + virtual ~RsHistorySerialiser() {} -private: - virtual uint32_t sizeHistoryMsgItem(RsHistoryMsgItem*); - virtual bool serialiseHistoryMsgItem (RsHistoryMsgItem* item, void* data, uint32_t* size); - virtual RsHistoryMsgItem* deserialiseHistoryMsgItem(void* data, uint32_t* size); + virtual RsItem *create_item(uint8_t service,uint8_t type) const ; }; /**************************************************************************/ diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index 9f14ee91e..ab47e9429 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -6,7 +6,7 @@ const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_NONE ( 0x0 const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_CONFIG ( 0x0001 ); const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE ( 0x0002 ); -RsItem *RsGenericSerializer::deserialise(void *data, uint32_t *size) +RsItem *RsServiceSerializer::deserialise(void *data, uint32_t *size) { uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; @@ -36,7 +36,36 @@ RsItem *RsGenericSerializer::deserialise(void *data, uint32_t *size) delete item ; return NULL ; } +RsItem *RsConfigSerializer::deserialise(void *data, uint32_t *size) +{ + uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; + RsItem *item = create_item(getRsItemClass(rstype),getRsItemSubType(rstype)) ; + + if(!item) + { + std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; + std::cerr << "(EE) Data is: " << RsUtil::BinToHex(static_cast(data),std::min(50u,*size)) << ((*size>50)?"...":"") << std::endl; + return NULL ; + } + + SerializeContext ctx(const_cast(static_cast(data)),*size,mFormat,mFlags); + ctx.mOffset = 8 ; + + item->serial_process(RsItem::DESERIALIZE, ctx) ; + + if(ctx.mSize != ctx.mOffset) + { + std::cerr << "RsSerializer::deserialise(): ERROR. offset does not match expected size!" << std::endl; + delete item ; + return NULL ; + } + if(ctx.mOk) + return item ; + + delete item ; + return NULL ; +} bool RsGenericSerializer::serialise(RsItem *item,void *data,uint32_t *size) { SerializeContext ctx(static_cast(data),0,mFormat,mFlags); diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 33e643215..3285becf9 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -25,14 +25,9 @@ public: static const SerializationFlags SERIALIZATION_FLAG_CONFIG ; // 0x0001 static const SerializationFlags SERIALIZATION_FLAG_SIGNATURE ; // 0x0002 - /*! create_item - * should be overloaded to create the correct type of item depending on the data - */ - virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const=0; - // The following functions overload RsSerialType. They *should not* need to be further overloaded. - RsItem *deserialise(void *data,uint32_t *size) ; + RsItem *deserialise(void *data,uint32_t *size) =0; bool serialise(RsItem *item,void *data,uint32_t *size) ; uint32_t size(RsItem *item) ; void print(RsItem *item) ; @@ -51,7 +46,6 @@ protected: : RsSerialType(RS_PKT_VERSION_SERVICE,service), mFormat(format),mFlags(flags) {} -private: SerializeContext::SerializationFormat mFormat ; SerializationFlags mFlags ; @@ -65,6 +59,13 @@ public: SerializationFlags flags = SERIALIZATION_FLAG_NONE) : RsGenericSerializer(service_id,format,flags) {} + + /*! create_item + * should be overloaded to create the correct type of item depending on the data + */ + virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const=0; + + RsItem *deserialise(void *data,uint32_t *size) ; }; class RsConfigSerializer: public RsGenericSerializer @@ -76,6 +77,13 @@ public: SerializationFlags flags = RsGenericSerializer::SERIALIZATION_FLAG_NONE) : RsGenericSerializer(config_class,config_type,format,flags) {} + + /*! create_item + * should be overloaded to create the correct type of item depending on the data + */ + virtual RsItem *create_item(uint8_t /* class */, uint8_t /* item_type */) const=0; + + RsItem *deserialise(void *data,uint32_t *size) ; }; From fcabe6359f7667b18e23844056f4d6dbf9464b51 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 18:51:51 +0200 Subject: [PATCH 44/94] switch RsConfigItems to new serialization --- libretroshare/src/ft/ftextralist.cc | 5 +- libretroshare/src/pqi/p3peermgr.cc | 3 +- libretroshare/src/serialiser/rsconfigitems.cc | 278 ++++++++++++++---- libretroshare/src/serialiser/rsconfigitems.h | 185 ++++-------- 4 files changed, 297 insertions(+), 174 deletions(-) diff --git a/libretroshare/src/ft/ftextralist.cc b/libretroshare/src/ft/ftextralist.cc index e63a5f1a8..8538a46a9 100644 --- a/libretroshare/src/ft/ftextralist.cc +++ b/libretroshare/src/ft/ftextralist.cc @@ -396,7 +396,8 @@ bool ftExtraList::saveList(bool &cleanup, std::list& sList) std::map::const_iterator it; for(it = mFiles.begin(); it != mFiles.end(); ++it) { - RsFileConfigItem_deprecated *fi = new RsFileConfigItem_deprecated(); + RsFileConfigItem *fi = new RsFileConfigItem(); + fi->file.path = (it->second).info.path; fi->file.name = (it->second).info.fname; fi->file.hash = (it->second).info.hash; @@ -429,7 +430,7 @@ bool ftExtraList::loadList(std::list& load) for(it = load.begin(); it != load.end(); ++it) { - RsFileConfigItem_deprecated *fi = dynamic_cast(*it); + RsFileConfigItem *fi = dynamic_cast(*it); if (!fi) { delete (*it); diff --git a/libretroshare/src/pqi/p3peermgr.cc b/libretroshare/src/pqi/p3peermgr.cc index 97e738a40..d26c4a950 100644 --- a/libretroshare/src/pqi/p3peermgr.cc +++ b/libretroshare/src/pqi/p3peermgr.cc @@ -2294,7 +2294,7 @@ bool p3PeerMgrIMPL::loadList(std::list& load) continue; } - +#ifdef TO_REMOVE RsPeerGroupItem_deprecated *gitem = dynamic_cast(*it) ; if (gitem) @@ -2331,6 +2331,7 @@ bool p3PeerMgrIMPL::loadList(std::list& load) continue; } +#endif RsNodeGroupItem *gitem2 = dynamic_cast(*it) ; diff --git a/libretroshare/src/serialiser/rsconfigitems.cc b/libretroshare/src/serialiser/rsconfigitems.cc index 9b94d454d..0c603ed3a 100644 --- a/libretroshare/src/serialiser/rsconfigitems.cc +++ b/libretroshare/src/serialiser/rsconfigitems.cc @@ -40,6 +40,37 @@ /*************************************************************************/ +RsItem *RsFileConfigSerialiser::create_item(uint8_t item_class,uint8_t item_type) const +{ + if(item_class != RS_PKT_CLASS_CONFIG) + return NULL ; + + switch(item_type) + { + case RS_PKT_SUBTYPE_FILE_TRANSFER: return new RsFileTransfer() ; + case RS_PKT_SUBTYPE_FILE_ITEM: return new RsFileConfigItem() ; + default: + return NULL ; + } +} +void RsFileTransfer::clear() +{ + + file.TlvClear(); + allPeerIds.TlvClear(); + cPeerId.clear() ; + state = 0; + in = false; + transferred = 0; + crate = 0; + trate = 0; + lrate = 0; + ltransfer = 0; + +} + + +#ifdef TO_REMOVE uint32_t RsFileConfigSerialiser::size(RsItem *i) { RsFileTransfer *rft; @@ -110,22 +141,6 @@ RsFileTransfer::~RsFileTransfer() return; } -void RsFileTransfer::clear() -{ - - file.TlvClear(); - allPeerIds.TlvClear(); - cPeerId.clear() ; - state = 0; - in = false; - transferred = 0; - crate = 0; - trate = 0; - lrate = 0; - ltransfer = 0; - -} - std::ostream &RsFileTransfer::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsFileTransfer", indent); @@ -231,7 +246,31 @@ uint32_t RsFileConfigSerialiser::sizeTransfer(RsFileTransfer *item) return s; } +#endif +void RsFileTransfer::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,file,"file") ; + RsTypeSerializer::serial_process(j,ctx,allPeerIds,"allPeerIds") ; + + RsTypeSerializer::serial_process (j,ctx,cPeerId,"cPeerId") ; + + RsTypeSerializer::serial_process (j,ctx,state,"state") ; + RsTypeSerializer::serial_process (j,ctx,in,"in") ; + + RsTypeSerializer::serial_process (j,ctx,transferred,"transferred") ; + + RsTypeSerializer::serial_process (j,ctx,crate,"crate") ; + RsTypeSerializer::serial_process (j,ctx,trate,"trate") ; + RsTypeSerializer::serial_process (j,ctx,lrate,"lrate") ; + RsTypeSerializer::serial_process (j,ctx,ltransfer,"ltransfer") ; + + RsTypeSerializer::serial_process (j,ctx,flags,"flags") ; + RsTypeSerializer::serial_process (j,ctx,chunk_strategy,"chunk_strategy") ; + RsTypeSerializer::serial_process (j,ctx,compressed_chunk_map,"compressed_chunk_map") ; +} + +#ifdef TO_REMOVE bool RsFileConfigSerialiser::serialiseTransfer(RsFileTransfer *item, void *data, uint32_t *pktsize) { uint32_t tlvsize = sizeTransfer(item); @@ -374,7 +413,16 @@ uint32_t RsFileConfigSerialiser::sizeFileItem(RsFileConfigItem *item) return s; } +#endif +void RsFileConfigItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,file,"file") ; + RsTypeSerializer::serial_process (j,ctx,flags,"flags") ; + RsTypeSerializer::serial_process(j,ctx,parent_groups,"parent_groups") ; +} + +#ifdef TO_REMOVE bool RsFileConfigSerialiser::serialiseFileItem(RsFileConfigItem *item, void *data, uint32_t *pktsize) { uint32_t tlvsize = sizeFileItem(item); @@ -540,6 +588,22 @@ RsGeneralConfigSerialiser::~RsGeneralConfigSerialiser() return; } +#endif + +RsItem *RsGeneralConfigSerialiser::create_item(uint8_t item_class,uint8_t item_type) const +{ + if(item_class != RS_PKT_TYPE_GENERAL_CONFIG) + return NULL ; + + switch(item_type) + { + case RS_PKT_SUBTYPE_KEY_VALUE: return new RsConfigKeyValueSet(); + default: + return NULL ; + } +} + +#ifdef TO_REMOVE uint32_t RsGeneralConfigSerialiser::size(RsItem *i) { RsConfigKeyValueSet *kvs; @@ -632,7 +696,14 @@ uint32_t RsGeneralConfigSerialiser::sizeKeyValueSet(RsConfigKeyValueSet *item return s; } +#endif +void RsConfigKeyValueSet::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tlvkvs,"tlvkvs") ; +} + +#ifdef TO_REMOVE /* serialise the data to the buffer */ bool RsGeneralConfigSerialiser::serialiseKeyValueSet(RsConfigKeyValueSet *item, void *data, uint32_t *pktsize) { @@ -745,7 +816,49 @@ RsPeerConfigSerialiser::~RsPeerConfigSerialiser() { return; } +#endif +RsItem *RsPeerConfigSerialiser::create_item(uint8_t item_class,uint8_t item_type) const +{ + if(item_class != RS_PKT_TYPE_PEER_CONFIG) + return NULL ; + + switch(item_type) + { + case RS_PKT_SUBTYPE_PEER_NET: return new RsPeerNetItem(); + case RS_PKT_SUBTYPE_PEER_STUN: return new RsPeerStunItem(); + case RS_PKT_SUBTYPE_NODE_GROUP: return new RsNodeGroupItem() ; + case RS_PKT_SUBTYPE_PEER_PERMISSIONS: return new RsPeerServicePermissionItem(); + case RS_PKT_SUBTYPE_PEER_BANDLIMITS: return new RsPeerBandwidthLimitsItem(); + default: + return NULL ; + } +} + +void RsPeerNetItem::clear() +{ + peerId.clear(); + pgpId.clear(); + location.clear(); + netMode = 0; + vs_disc = 0; + vs_dht = 0; + lastContact = 0; + + localAddrV4.TlvClear(); + extAddrV4.TlvClear(); + localAddrV6.TlvClear(); + extAddrV6.TlvClear(); + + dyndns.clear(); + + localAddrList.TlvClear(); + extAddrList.TlvClear(); + + domain_addr.clear(); + domain_port = 0; +} +#ifdef TO_REMOVE uint32_t RsPeerConfigSerialiser::size(RsItem *i) { RsPeerStunItem *psi; @@ -855,29 +968,7 @@ RsPeerNetItem::~RsPeerNetItem() return; } -void RsPeerNetItem::clear() -{ - peerId.clear(); - pgpId.clear(); - location.clear(); - netMode = 0; - vs_disc = 0; - vs_dht = 0; - lastContact = 0; - localAddrV4.TlvClear(); - extAddrV4.TlvClear(); - localAddrV6.TlvClear(); - extAddrV6.TlvClear(); - - dyndns.clear(); - - localAddrList.TlvClear(); - extAddrList.TlvClear(); - - domain_addr.clear(); - domain_port = 0; -} std::ostream &RsPeerNetItem::print(std::ostream &out, uint16_t indent) { @@ -963,7 +1054,34 @@ uint32_t RsPeerConfigSerialiser::sizeNet(RsPeerNetItem *i) return s; } +#endif +void RsPeerNetItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,peerId,"peerId") ; + RsTypeSerializer::serial_process(j,ctx,pgpId,"pgpId") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_LOCATION,location,"location") ; + + RsTypeSerializer::serial_process(j,ctx,netMode,"netMode") ; + RsTypeSerializer::serial_process(j,ctx,vs_disc,"vs_disc") ; + RsTypeSerializer::serial_process(j,ctx,vs_dht,"vs_dht") ; + RsTypeSerializer::serial_process(j,ctx,lastContact,"lastContact") ; + + RsTypeSerializer::serial_process(j,ctx,localAddrV4,"localAddrV4") ; + RsTypeSerializer::serial_process(j,ctx,extAddrV4,"extAddrV4") ; + RsTypeSerializer::serial_process(j,ctx,localAddrV6,"localAddrV6") ; + RsTypeSerializer::serial_process(j,ctx,extAddrV6,"extAddrV6") ; + + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DYNDNS,dyndns,"dyndns") ; + + RsTypeSerializer::serial_process(j,ctx,localAddrList,"localAddrList") ; + RsTypeSerializer::serial_process(j,ctx,extAddrList,"extAddrList") ; + + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DOMADDR,domain_addr,"domain_addr") ; + RsTypeSerializer::serial_process(j,ctx,domain_port,"domain_port") ; +} + +#ifdef TO_REMOVE bool RsPeerConfigSerialiser::serialiseNet(RsPeerNetItem *item, void *data, uint32_t *size) { uint32_t tlvsize = RsPeerConfigSerialiser::sizeNet(item); @@ -1119,7 +1237,14 @@ uint32_t RsPeerConfigSerialiser::sizePeerBandwidthLimits(RsPeerBandwidthLimitsIt return s; } +#endif +void RsPeerBandwidthLimitsItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,peers,"peers") ; +} + +#ifdef TO_REMOVE bool RsPeerConfigSerialiser::serialisePeerBandwidthLimits(RsPeerBandwidthLimitsItem *item, void *data, uint32_t *size) { uint32_t tlvsize = RsPeerConfigSerialiser::sizePeerBandwidthLimits(item); @@ -1296,7 +1421,50 @@ uint32_t RsPeerConfigSerialiser::sizeStun(RsPeerStunItem *i) return s; } +#endif +void RsPeerStunItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,stunList,"stunList") ; +} + +template<> uint32_t RsTypeSerializer::serial_size(const PeerBandwidthLimits& s) +{ + return 4+4 ; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const PeerBandwidthLimits& s) +{ + bool ok = true ; + ok = ok && setRawUInt32(data,size,&offset,s.max_up_rate_kbs); + ok = ok && setRawUInt32(data,size,&offset,s.max_dl_rate_kbs); + return ok; +} + +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,PeerBandwidthLimits& s) +{ + bool ok = true ; + ok = ok && getRawUInt32(data,size,&offset,&s.max_up_rate_kbs); + ok = ok && getRawUInt32(data,size,&offset,&s.max_dl_rate_kbs); + return ok; +} + +template<> void RsTypeSerializer::print_data(const std::string& n, const PeerBandwidthLimits& s) +{ + std::cerr << " [Peer BW limit] " << s.max_up_rate_kbs << " / " << s.max_dl_rate_kbs << std::endl; +} + +RsNodeGroupItem::RsNodeGroupItem(const RsGroupInfo& g) + :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_NODE_GROUP) +{ + id = g.id ; + name = g.name ; + flag = g.flag ; + pgpList.ids = g.peerIds; +} + + +#ifdef TO_REMOVE bool RsPeerConfigSerialiser::serialiseStun(RsPeerStunItem *item, void *data, uint32_t *size) { uint32_t tlvsize = RsPeerConfigSerialiser::sizeStun(item); @@ -1382,18 +1550,6 @@ RsPeerStunItem *RsPeerConfigSerialiser::deserialiseStun(void *data, uint32_t *si } /*************************************************************************/ -RsNodeGroupItem::RsNodeGroupItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_NODE_GROUP) -{ -} - -RsNodeGroupItem::RsNodeGroupItem(const RsGroupInfo& g) - :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_NODE_GROUP) -{ - id = g.id ; - name = g.name ; - flag = g.flag ; - pgpList.ids = g.peerIds; -} void RsNodeGroupItem::clear() { @@ -1531,6 +1687,20 @@ uint32_t RsPeerConfigSerialiser::sizeGroup(RsNodeGroupItem *i) return s; } +#endif + +void RsNodeGroupItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + uint32_t v=0 ; + + RsTypeSerializer::serial_process(j,ctx,v,"dummy field 0") ; + RsTypeSerializer::serial_process (j,ctx,id,"id") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,name,"name") ; + RsTypeSerializer::serial_process(j,ctx,flag,"flag") ; + RsTypeSerializer::serial_process(j,ctx,pgpList,"pgpList") ; +} + +#ifdef TO_REMOVE bool RsPeerConfigSerialiser::serialiseGroup(RsNodeGroupItem *item, void *data, uint32_t *size) { uint32_t tlvsize = RsPeerConfigSerialiser::sizeGroup(item); @@ -1650,7 +1820,14 @@ uint32_t RsPeerConfigSerialiser::sizePermissions(RsPeerServicePermissionItem *i) return s; } +#endif +void RsPeerServicePermissionItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,pgp_ids,"pgp_ids") ; +} + +#ifdef TO_REMOVE bool RsPeerConfigSerialiser::serialisePermissions(RsPeerServicePermissionItem *item, void *data, uint32_t *size) { uint32_t tlvsize = RsPeerConfigSerialiser::sizePermissions(item); @@ -1932,6 +2109,7 @@ RsItem *RsCacheConfigSerialiser::deserialise(void *data, uint32_t *size) } +#endif diff --git a/libretroshare/src/serialiser/rsconfigitems.h b/libretroshare/src/serialiser/rsconfigitems.h index 3d3d50a97..84b5a176f 100644 --- a/libretroshare/src/serialiser/rsconfigitems.h +++ b/libretroshare/src/serialiser/rsconfigitems.h @@ -37,6 +37,8 @@ #include "serialiser/rstlvkeyvalue.h" #include "serialiser/rstlvaddrs.h" +#include "serialization/rsserializer.h" + class RsGroupInfo; const uint8_t RS_PKT_TYPE_GENERAL_CONFIG = 0x01; @@ -68,21 +70,22 @@ const uint8_t RS_PKT_SUBTYPE_FILE_ITEM = 0x03; class RsPeerNetItem: public RsItem { - public: - RsPeerNetItem() - :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_PEER_CONFIG, - RS_PKT_SUBTYPE_PEER_NET) - { return; } -virtual ~RsPeerNetItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); +public: + RsPeerNetItem() + :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, + RS_PKT_TYPE_PEER_CONFIG, + RS_PKT_SUBTYPE_PEER_NET) {} + + virtual ~RsPeerNetItem(){} + virtual void clear(); + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); /* networking information */ RsPeerId peerId; /* Mandatory */ - RsPgpId pgpId; /* Mandatory */ - std::string location; /* Mandatory */ - uint32_t netMode; /* Mandatory */ + RsPgpId pgpId; /* Mandatory */ + std::string location; /* Mandatory */ + uint32_t netMode; /* Mandatory */ uint16_t vs_disc; /* Mandatory */ uint16_t vs_dht; /* Mandatory */ uint32_t lastContact; /* Mandatory */ @@ -92,14 +95,14 @@ std::ostream &print(std::ostream &out, uint16_t indent = 0); RsTlvIpAddress localAddrV6; /* Mandatory */ RsTlvIpAddress extAddrV6; /* Mandatory */ - std::string dyndns; + std::string dyndns; RsTlvIpAddrSet localAddrList; RsTlvIpAddrSet extAddrList; // for proxy connection. std::string domain_addr; - uint16_t domain_port; + uint16_t domain_port; }; // This item should be merged with the next item, but that is not backward compatible. @@ -114,7 +117,8 @@ class RsPeerServicePermissionItem : public RsItem pgp_ids.clear() ; service_flags.clear() ; } - std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(SerializeJob j,SerializeContext& ctx); + /* Mandatory */ std::vector pgp_ids ; @@ -130,12 +134,13 @@ class RsPeerBandwidthLimitsItem : public RsItem { peers.clear() ; } - std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(SerializeJob j,SerializeContext& ctx); /* Mandatory */ std::map peers ; }; +#ifdef TO_REMOVE class RsPeerGroupItem_deprecated : public RsItem { public: @@ -157,18 +162,20 @@ public: RsTlvPgpIdSet pgpList; }; +#endif class RsNodeGroupItem: public RsItem { public: - RsNodeGroupItem(); + RsNodeGroupItem(): RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_NODE_GROUP){} virtual ~RsNodeGroupItem() {} - virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void clear() { pgpList.TlvClear();} explicit RsNodeGroupItem(const RsGroupInfo&) ; + virtual void serial_process(SerializeJob j,SerializeContext& ctx); + // /* set data from RsGroupInfo to RsPeerGroupItem */ // void set(RsGroupInfo &groupInfo); // /* get data from RsGroupInfo to RsPeerGroupItem */ @@ -184,63 +191,32 @@ public: class RsPeerStunItem: public RsItem { - public: - RsPeerStunItem() - :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_PEER_CONFIG, - RS_PKT_SUBTYPE_PEER_STUN) - { return; } -virtual ~RsPeerStunItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); +public: + RsPeerStunItem() + :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, + RS_PKT_TYPE_PEER_CONFIG, + RS_PKT_SUBTYPE_PEER_STUN) {} + virtual ~RsPeerStunItem(){} + virtual void clear() { stunList.TlvClear() ;} + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); RsTlvPeerIdSet stunList; /* Mandatory */ }; -class RsPeerConfigSerialiser: public RsSerialType +class RsPeerConfigSerialiser: public RsConfigSerializer { public: - RsPeerConfigSerialiser() - :RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_PEER_CONFIG) - { return; } + RsPeerConfigSerialiser() :RsConfigSerializer(RS_PKT_CLASS_CONFIG,RS_PKT_TYPE_PEER_CONFIG) {} -virtual ~RsPeerConfigSerialiser(); - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); + virtual ~RsPeerConfigSerialiser(){} - private: - - -virtual uint32_t sizeNet(RsPeerNetItem *); -virtual bool serialiseNet (RsPeerNetItem *item, void *data, uint32_t *size); -virtual RsPeerNetItem *deserialiseNet(void *data, uint32_t *size); - -virtual uint32_t sizeStun(RsPeerStunItem *); -virtual bool serialiseStun (RsPeerStunItem *item, void *data, uint32_t *size); -virtual RsPeerStunItem * deserialiseStun(void *data, uint32_t *size); - -virtual uint32_t sizeGroup(RsNodeGroupItem *); -virtual bool serialiseGroup (RsNodeGroupItem *item, void *data, uint32_t *size); -virtual RsNodeGroupItem *deserialiseGroup(void *data, uint32_t *size); -virtual RsPeerGroupItem_deprecated * deserialiseGroup_deprecated(void *data, uint32_t *size); - -virtual uint32_t sizePeerBandwidthLimits(RsPeerBandwidthLimitsItem *); -virtual bool serialisePeerBandwidthLimits (RsPeerBandwidthLimitsItem *item, void *data, uint32_t *size); -virtual RsPeerBandwidthLimitsItem *deserialisePeerBandwidthLimits(void *data, uint32_t *size); - -virtual uint32_t sizePermissions(RsPeerServicePermissionItem *); -virtual bool serialisePermissions (RsPeerServicePermissionItem *item, void *data, uint32_t *size); -virtual RsPeerServicePermissionItem * deserialisePermissions(void *data, uint32_t *size); + virtual RsItem *create_item(uint8_t item_class,uint8_t item_type) const ; }; -/**************************************************************************/ -/**************************************************************************/ - /**************************************************************************/ +#ifdef TO_REMOVE class RsCacheConfig: public RsItem { public: @@ -281,6 +257,7 @@ virtual bool serialise (RsItem *item, void *data, uint32_t *size); virtual RsItem * deserialise(void *data, uint32_t *size); }; +#endif /**************************************************************************/ @@ -299,14 +276,15 @@ class RsFileTransfer: public RsItem flags = 0; chunk_strategy = 0; } - virtual ~RsFileTransfer(); + virtual ~RsFileTransfer(){} virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); RsTlvFileItem file; RsTlvPeerIdSet allPeerIds; - RsPeerId cPeerId; + RsPeerId cPeerId; uint16_t state; uint16_t in; @@ -328,6 +306,7 @@ class RsFileTransfer: public RsItem const uint32_t RS_FILE_CONFIG_CLEANUP_DELETE = 0x0001; +#ifdef TO_REMOVE /* Used by ft / extralist / configdirs / anyone who wants a basic file */ class RsFileConfigItem_deprecated: public RsItem { @@ -345,18 +324,16 @@ public: uint32_t flags; std::list parent_groups ; }; +#endif class RsFileConfigItem: public RsItem { public: - RsFileConfigItem() - :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_FILE_CONFIG, - RS_PKT_SUBTYPE_FILE_ITEM) - {} + RsFileConfigItem() :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_FILE_CONFIG, RS_PKT_SUBTYPE_FILE_ITEM) {} virtual ~RsFileConfigItem() {} - virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void clear() { parent_groups.TlvClear(); } + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); RsTlvFileItem file; uint32_t flags; @@ -364,31 +341,13 @@ public: }; /**************************************************************************/ -class RsFileConfigSerialiser: public RsSerialType +class RsFileConfigSerialiser: public RsConfigSerializer { public: - RsFileConfigSerialiser() - :RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_FILE_CONFIG) - { return; } -virtual ~RsFileConfigSerialiser() { return; } + RsFileConfigSerialiser() :RsConfigSerializer(RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_FILE_CONFIG) { } + virtual ~RsFileConfigSerialiser() {} -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - -virtual uint32_t sizeTransfer(RsFileTransfer *); -virtual bool serialiseTransfer(RsFileTransfer *item, void *data, uint32_t *size); -virtual RsFileTransfer * deserialiseTransfer(void *data, uint32_t *size); - -virtual RsFileConfigItem_deprecated * deserialiseFileItem_deprecated(void *data, uint32_t *size); - -virtual uint32_t sizeFileItem(RsFileConfigItem *); -virtual bool serialiseFileItem(RsFileConfigItem *item, void *data, uint32_t *size); -virtual RsFileConfigItem *deserialiseFileItem(void *data, uint32_t *size); - + virtual RsItem *create_item(uint8_t item_class,uint8_t item_type) const ; }; /**************************************************************************/ @@ -397,39 +356,23 @@ virtual RsFileConfigItem *deserialiseFileItem(void *data, uint32_t *size); class RsConfigKeyValueSet: public RsItem { - public: - RsConfigKeyValueSet() - :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_GENERAL_CONFIG, - RS_PKT_SUBTYPE_KEY_VALUE) - { return; } -virtual ~RsConfigKeyValueSet(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); +public: + RsConfigKeyValueSet() :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_GENERAL_CONFIG, RS_PKT_SUBTYPE_KEY_VALUE) {} + virtual ~RsConfigKeyValueSet(){} + virtual void clear() { tlvkvs.TlvClear();} + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); RsTlvKeyValueSet tlvkvs; }; -class RsGeneralConfigSerialiser: public RsSerialType +class RsGeneralConfigSerialiser: public RsConfigSerializer { public: - RsGeneralConfigSerialiser() - :RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_GENERAL_CONFIG) - { return; } - -virtual ~RsGeneralConfigSerialiser(); - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: -uint32_t sizeKeyValueSet(RsConfigKeyValueSet *item); -bool serialiseKeyValueSet(RsConfigKeyValueSet *item, void *data, uint32_t *pktsize); -RsConfigKeyValueSet *deserialiseKeyValueSet(void *data, uint32_t *pktsize); + RsGeneralConfigSerialiser() :RsConfigSerializer(RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_GENERAL_CONFIG) {} + virtual RsItem *create_item(uint8_t item_class,uint8_t item_type) const ; }; #endif /* RS_CONFIG_ITEMS_SERIALISER_H */ From 43b3b877822960dde58f33f8e52013be694d77f4 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 22:36:03 +0200 Subject: [PATCH 45/94] fixed a few bugs in config items --- libretroshare/src/serialiser/rsconfigitems.cc | 43 ++++++++++++++----- libretroshare/src/serialiser/rsconfigitems.h | 8 ++-- .../src/serialization/rsserializer.cc | 8 ++-- 3 files changed, 41 insertions(+), 18 deletions(-) diff --git a/libretroshare/src/serialiser/rsconfigitems.cc b/libretroshare/src/serialiser/rsconfigitems.cc index 0c603ed3a..61b888f2c 100644 --- a/libretroshare/src/serialiser/rsconfigitems.cc +++ b/libretroshare/src/serialiser/rsconfigitems.cc @@ -40,12 +40,12 @@ /*************************************************************************/ -RsItem *RsFileConfigSerialiser::create_item(uint8_t item_class,uint8_t item_type) const +RsItem *RsFileConfigSerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const { - if(item_class != RS_PKT_CLASS_CONFIG) + if(item_type != RS_PKT_TYPE_FILE_CONFIG) return NULL ; - switch(item_type) + switch(item_subtype) { case RS_PKT_SUBTYPE_FILE_TRANSFER: return new RsFileTransfer() ; case RS_PKT_SUBTYPE_FILE_ITEM: return new RsFileConfigItem() ; @@ -590,12 +590,12 @@ RsGeneralConfigSerialiser::~RsGeneralConfigSerialiser() #endif -RsItem *RsGeneralConfigSerialiser::create_item(uint8_t item_class,uint8_t item_type) const +RsItem *RsGeneralConfigSerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const { - if(item_class != RS_PKT_TYPE_GENERAL_CONFIG) + if(item_type != RS_PKT_TYPE_GENERAL_CONFIG) return NULL ; - switch(item_type) + switch(item_subtype) { case RS_PKT_SUBTYPE_KEY_VALUE: return new RsConfigKeyValueSet(); default: @@ -818,12 +818,12 @@ RsPeerConfigSerialiser::~RsPeerConfigSerialiser() } #endif -RsItem *RsPeerConfigSerialiser::create_item(uint8_t item_class,uint8_t item_type) const +RsItem *RsPeerConfigSerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const { - if(item_class != RS_PKT_TYPE_PEER_CONFIG) + if(item_type != RS_PKT_TYPE_PEER_CONFIG) return NULL ; - switch(item_type) + switch(item_subtype) { case RS_PKT_SUBTYPE_PEER_NET: return new RsPeerNetItem(); case RS_PKT_SUBTYPE_PEER_STUN: return new RsPeerStunItem(); @@ -1824,7 +1824,30 @@ uint32_t RsPeerConfigSerialiser::sizePermissions(RsPeerServicePermissionItem *i) void RsPeerServicePermissionItem::serial_process(SerializeJob j,SerializeContext& ctx) { - RsTypeSerializer::serial_process(j,ctx,pgp_ids,"pgp_ids") ; + // We need to hack this because of backward compatibility. The correct way to do it would be: + // + // RsTypeSerializer::serial_process(j,ctx,pgp_ids,"pgp_ids") ; + // RsTypeSerializer::serial_process(j,ctx,service_flags,"service_flags") ; + + if(j == RsItem::DESERIALIZE) + { + uint32_t v=0 ; + RsTypeSerializer::serial_process(j,ctx,v,"pgp_ids.size()") ; + + pgp_ids.resize(v) ; + service_flags.resize(v) ; + } + else + { + uint32_t s = pgp_ids.size(); + RsTypeSerializer::serial_process(j,ctx,s,"pgp_ids.size()") ; + } + + for(uint32_t i=0;i + #include "util/rsprint.h" #include "serialization/rsserializer.h" #include "serialization/rstypeserializer.h" @@ -14,7 +16,7 @@ RsItem *RsServiceSerializer::deserialise(void *data, uint32_t *size) if(!item) { - std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; + std::cerr << "(EE) " << typeid(*this).name() << ": cannot deserialise unknown item subtype " << std::hex << getRsItemSubType(rstype) << std::dec << std::endl; std::cerr << "(EE) Data is: " << RsUtil::BinToHex(static_cast(data),std::min(50u,*size)) << ((*size>50)?"...":"") << std::endl; return NULL ; } @@ -40,11 +42,11 @@ RsItem *RsConfigSerializer::deserialise(void *data, uint32_t *size) { uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; - RsItem *item = create_item(getRsItemClass(rstype),getRsItemSubType(rstype)) ; + RsItem *item = create_item(getRsItemType(rstype),getRsItemSubType(rstype)) ; if(!item) { - std::cerr << "(EE) cannot deserialise: unknown item type " << std::hex << rstype << std::dec << std::endl; + std::cerr << "(EE) " << typeid(*this).name() << ": cannot deserialise unknown item subtype " << std::hex << getRsItemSubType(rstype) << std::dec << std::endl; std::cerr << "(EE) Data is: " << RsUtil::BinToHex(static_cast(data),std::min(50u,*size)) << ((*size>50)?"...":"") << std::endl; return NULL ; } From f7338d4a3de73f6f68339a0b0c0fc345dc38d1f4 Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 22:39:05 +0200 Subject: [PATCH 46/94] removed old code --- libretroshare/src/serialiser/rsconfigitems.cc | 1871 ----------------- 1 file changed, 1871 deletions(-) diff --git a/libretroshare/src/serialiser/rsconfigitems.cc b/libretroshare/src/serialiser/rsconfigitems.cc index 61b888f2c..856294ca3 100644 --- a/libretroshare/src/serialiser/rsconfigitems.cc +++ b/libretroshare/src/serialiser/rsconfigitems.cc @@ -69,185 +69,6 @@ void RsFileTransfer::clear() } - -#ifdef TO_REMOVE -uint32_t RsFileConfigSerialiser::size(RsItem *i) -{ - RsFileTransfer *rft; - RsFileConfigItem *rfj; - - if (NULL != (rft = dynamic_cast(i))) - { - return sizeTransfer(rft); - } - if (NULL != (rfj = dynamic_cast(i))) - { - return sizeFileItem(rfj); - } - return 0; -} - -/* serialise the data to the buffer */ -bool RsFileConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsFileTransfer *rft; - RsFileConfigItem *rfj; - - if (NULL != (rft = dynamic_cast(i))) - { - return serialiseTransfer(rft, data, pktsize); - } - if (NULL != (rfj = dynamic_cast(i))) - { - return serialiseFileItem(rfj, data, pktsize); - } - return false; -} - -RsItem *RsFileConfigSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_FILE_CONFIG != getRsItemType(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_FILE_TRANSFER: - return deserialiseTransfer(data, pktsize); - break; - case RS_PKT_SUBTYPE_FILE_ITEM_deprecated: - return deserialiseFileItem_deprecated(data, pktsize); - break; - case RS_PKT_SUBTYPE_FILE_ITEM: - return deserialiseFileItem(data, pktsize); - break; - default: - return NULL; - break; - } - return NULL; -} - -/*************************************************************************/ - -RsFileTransfer::~RsFileTransfer() -{ - return; -} - -std::ostream &RsFileTransfer::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileTransfer", indent); - uint16_t int_Indent = indent + 2; - file.print(out, int_Indent); - allPeerIds.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "cPeerId: " << cPeerId << std::endl; - - printIndent(out, int_Indent); - out << "State: " << state << std::endl; - printIndent(out, int_Indent); - out << "In/Out: " << in << std::endl; - - printIndent(out, int_Indent); - out << "Transferred: " << transferred << std::endl; - - printIndent(out, int_Indent); - out << "crate: " << crate << std::endl; - printIndent(out, int_Indent); - out << "trate: " << trate << std::endl; - printIndent(out, int_Indent); - out << "lrate: " << lrate << std::endl; - printIndent(out, int_Indent); - out << "ltransfer: " << ltransfer << std::endl; - - printRsItemEnd(out, "RsFileTransfer", indent); - return out; - -} - -/*************************************************************************/ -/*************************************************************************/ - -void RsFileConfigItem_deprecated::clear() -{ - file.TlvClear(); - flags = 0; - parent_groups.clear() ; -} - -void RsFileConfigItem::clear() -{ - file.TlvClear(); - flags = 0; - parent_groups.TlvClear() ; -} -std::ostream &RsFileConfigItem_deprecated::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileConfigItem", indent); - uint16_t int_Indent = indent + 2; - file.print(out, int_Indent); - - printIndent(out, int_Indent); out << "flags: " << flags << std::endl; - printIndent(out, int_Indent); out << "groups:" ; - - for(std::list::const_iterator it(parent_groups.begin());it!=parent_groups.end();++it) - out << (*it) << " " ; - out << std::endl; - - printRsItemEnd(out, "RsFileConfigItem", indent); - return out; -} - -std::ostream &RsFileConfigItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsFileConfigItem", indent); - uint16_t int_Indent = indent + 2; - file.print(out, int_Indent); - - printIndent(out, int_Indent); out << "flags: " << flags << std::endl; - printIndent(out, int_Indent); out << "groups:" ; - - for(std::set::const_iterator it(parent_groups.ids.begin());it!=parent_groups.ids.end();++it) - out << (*it) << " " ; - out << std::endl; - - printRsItemEnd(out, "RsFileConfigItem", indent); - return out; -} -/*************************************************************************/ -/*************************************************************************/ - - -uint32_t RsFileConfigSerialiser::sizeTransfer(RsFileTransfer *item) -{ - uint32_t s = 8; /* header */ - s += item->file.TlvSize(); - s += item->allPeerIds.TlvSize(); - s += RsPeerId::SIZE_IN_BYTES; - s += 2; /* state */ - s += 2; /* in/out */ - s += 8; /* transferred */ - s += 4; /* crate */ - s += 4; /* trate */ - s += 4; /* lrate */ - s += 4; /* ltransfer */ - s += 4; // chunk_strategy - s += 4; // flags - s += 4; // chunk map size - s += 4*item->compressed_chunk_map._map.size(); // compressed_chunk_map - - return s; -} -#endif - void RsFileTransfer::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,file,"file") ; @@ -270,151 +91,6 @@ void RsFileTransfer::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process (j,ctx,compressed_chunk_map,"compressed_chunk_map") ; } -#ifdef TO_REMOVE -bool RsFileConfigSerialiser::serialiseTransfer(RsFileTransfer *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeTransfer(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileConfigSerialiser::serialiseTransfer() Header: " << ok << std::endl; - std::cerr << "RsFileConfigSerialiser::serialiseTransfer() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->file.SetTlv(data, tlvsize, &offset); - ok &= item->allPeerIds.SetTlv(data, tlvsize, &offset); - - ok &= item->cPeerId.serialise(data, tlvsize, offset) ; - - ok &= setRawUInt16(data, tlvsize, &offset, item->state); - ok &= setRawUInt16(data, tlvsize, &offset, item->in); - - ok &= setRawUInt64(data, tlvsize, &offset, item->transferred); - - ok &= setRawUInt32(data, tlvsize, &offset, item->crate); - ok &= setRawUInt32(data, tlvsize, &offset, item->trate); - ok &= setRawUInt32(data, tlvsize, &offset, item->lrate); - ok &= setRawUInt32(data, tlvsize, &offset, item->ltransfer); - - ok &= setRawUInt32(data, tlvsize, &offset, item->flags); - ok &= setRawUInt32(data, tlvsize, &offset, item->chunk_strategy); - ok &= setRawUInt32(data, tlvsize, &offset, item->compressed_chunk_map._map.size()); - - for(uint32_t i=0;icompressed_chunk_map._map.size();++i) - ok &= setRawUInt32(data, tlvsize, &offset, item->compressed_chunk_map._map[i]); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsFileConfigSerialiser::serialiseTransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsFileTransfer *RsFileConfigSerialiser::deserialiseTransfer(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_FILE_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_FILE_TRANSFER != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsFileTransfer *item = new RsFileTransfer(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->file.GetTlv(data, rssize, &offset); - ok &= item->allPeerIds.GetTlv(data, rssize, &offset); - - ok &= item->cPeerId.deserialise(data, rssize, offset) ; - - /* data */ - ok &= getRawUInt16(data, rssize, &offset, &(item->state)); - ok &= getRawUInt16(data, rssize, &offset, &(item->in)); - ok &= getRawUInt64(data, rssize, &offset, &(item->transferred)); - ok &= getRawUInt32(data, rssize, &offset, &(item->crate)); - ok &= getRawUInt32(data, rssize, &offset, &(item->trate)); - ok &= getRawUInt32(data, rssize, &offset, &(item->lrate)); - ok &= getRawUInt32(data, rssize, &offset, &(item->ltransfer)); - - ok &= getRawUInt32(data, rssize, &offset, &(item->flags)); - ok &= getRawUInt32(data, rssize, &offset, &(item->chunk_strategy)); - uint32_t map_size = 0 ; - ok &= getRawUInt32(data, rssize, &offset, &map_size); - - item->compressed_chunk_map._map.resize(map_size) ; - for(uint32_t i=0;icompressed_chunk_map._map[i])); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ -/*************************************************************************/ - - -uint32_t RsFileConfigSerialiser::sizeFileItem(RsFileConfigItem *item) -{ - uint32_t s = 8; /* header */ - s += item->file.TlvSize(); - s += 4; // flags - - s += item->parent_groups.TlvSize() ; - - return s; -} -#endif - void RsFileConfigItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,file,"file") ; @@ -422,174 +98,6 @@ void RsFileConfigItem::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process(j,ctx,parent_groups,"parent_groups") ; } -#ifdef TO_REMOVE -bool RsFileConfigSerialiser::serialiseFileItem(RsFileConfigItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeFileItem(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileConfigSerialiser::serialiseFileItem() Header: " << ok << std::endl; - std::cerr << "RsFileConfigSerialiser::serialiseFileItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->file.SetTlv(data, tlvsize, &offset); - ok &= setRawUInt32(data, tlvsize, &offset, item->flags); - ok &= item->parent_groups.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsFileConfigSerialiser::serialiseFileItem() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsFileConfigItem_deprecated *RsFileConfigSerialiser::deserialiseFileItem_deprecated(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_FILE_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_FILE_ITEM_deprecated != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsFileConfigItem_deprecated *item = new RsFileConfigItem_deprecated(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->file.GetTlv(data, rssize, &offset); - ok &= getRawUInt32(data, rssize, &offset, &(item->flags)); - - while(offset < rssize) - { - std::string tmp ; - if(GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GROUPID, tmp)) - item->parent_groups.push_back(tmp) ; - else - break ; - } - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} -RsFileConfigItem *RsFileConfigSerialiser::deserialiseFileItem(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_FILE_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_FILE_ITEM != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsFileConfigItem *item = new RsFileConfigItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->file.GetTlv(data, rssize, &offset); - ok &= getRawUInt32(data, rssize, &offset, &(item->flags)); - ok &= item->parent_groups.GetTlv(data, rssize, &offset) ; - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - - - - -/*************************************************************************/ -/*************************************************************************/ -/*************************************************************************/ -/*************************************************************************/ -/*************************************************************************/ - -RsGeneralConfigSerialiser::~RsGeneralConfigSerialiser() -{ - return; -} - -#endif - RsItem *RsGeneralConfigSerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const { if(item_type != RS_PKT_TYPE_GENERAL_CONFIG) @@ -603,221 +111,11 @@ RsItem *RsGeneralConfigSerialiser::create_item(uint8_t item_type,uint8_t item_su } } -#ifdef TO_REMOVE -uint32_t RsGeneralConfigSerialiser::size(RsItem *i) -{ - RsConfigKeyValueSet *kvs; - - if (NULL != (kvs = dynamic_cast(i))) - { - return sizeKeyValueSet(kvs); - } - else if (NULL != (kvs = dynamic_cast(i))) - { - return sizeKeyValueSet(kvs); - } - - return 0; -} - -/* serialise the data to the buffer */ -bool RsGeneralConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsConfigKeyValueSet *kvs; - - /* do reply first - as it is derived from Item */ - if (NULL != (kvs = dynamic_cast(i))) - { - return serialiseKeyValueSet(kvs, data, pktsize); - } - else if (NULL != (kvs = dynamic_cast(i))) - { - return serialiseKeyValueSet(kvs, data, pktsize); - } - - return false; -} - -RsItem *RsGeneralConfigSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_GENERAL_CONFIG != getRsItemType(rstype))) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsGeneralConfigSerialiser::deserialise() Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_KEY_VALUE: - return deserialiseKeyValueSet(data, pktsize); - break; - default: - return NULL; - break; - } - return NULL; -} - -/*************************************************************************/ - -RsConfigKeyValueSet::~RsConfigKeyValueSet() -{ - return; -} - -void RsConfigKeyValueSet::clear() -{ - tlvkvs.pairs.clear(); -} - -std::ostream &RsConfigKeyValueSet::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsConfigKeyValueSet", indent); - uint16_t int_Indent = indent + 2; - - tlvkvs.print(out, int_Indent); - - printRsItemEnd(out, "RsConfigKeyValueSet", indent); - return out; -} - - -uint32_t RsGeneralConfigSerialiser::sizeKeyValueSet(RsConfigKeyValueSet *item) -{ - uint32_t s = 8; /* header */ - s += item->tlvkvs.TlvSize(); - - return s; -} -#endif - void RsConfigKeyValueSet::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tlvkvs,"tlvkvs") ; } -#ifdef TO_REMOVE -/* serialise the data to the buffer */ -bool RsGeneralConfigSerialiser::serialiseKeyValueSet(RsConfigKeyValueSet *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeKeyValueSet(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGeneralConfigSerialiser::serialiseKeyValueSet() Header: " << ok << std::endl; - std::cerr << "RsGeneralConfigSerialiser::serialiseKeyValueSet() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->tlvkvs.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsGeneralConfigSerialiser::serialiseKeyValueSet() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsConfigKeyValueSet *RsGeneralConfigSerialiser::deserialiseKeyValueSet(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_GENERAL_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_KEY_VALUE != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsGeneralConfigSerialiser::deserialiseKeyValueSet() Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsGeneralConfigSerialiser::deserialiseKeyValueSet() Not Enough Space" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsConfigKeyValueSet *item = new RsConfigKeyValueSet(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->tlvkvs.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsGeneralConfigSerialiser::deserialiseKeyValueSet() offset != rssize" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsGeneralConfigSerialiser::deserialiseKeyValueSet() ok = false" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ -/*************************************************************************/ -/*************************************************************************/ -/*************************************************************************/ -/*************************************************************************/ - -RsPeerConfigSerialiser::~RsPeerConfigSerialiser() -{ - return; -} -#endif - RsItem *RsPeerConfigSerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const { if(item_type != RS_PKT_TYPE_PEER_CONFIG) @@ -858,204 +156,6 @@ void RsPeerNetItem::clear() domain_addr.clear(); domain_port = 0; } -#ifdef TO_REMOVE -uint32_t RsPeerConfigSerialiser::size(RsItem *i) -{ - RsPeerStunItem *psi; - RsPeerNetItem *pni; - RsNodeGroupItem *pgi; - RsPeerServicePermissionItem *pri; - RsPeerBandwidthLimitsItem *pblitem; - - if (NULL != (pni = dynamic_cast(i))) - { - return sizeNet(pni); - } - else if (NULL != (psi = dynamic_cast(i))) - { - return sizeStun(psi); - } - else if (NULL != (pgi = dynamic_cast(i))) - { - return sizeGroup(pgi); - } - else if (NULL != (pri = dynamic_cast(i))) - { - return sizePermissions(pri); - } - else if (NULL != (pblitem = dynamic_cast(i))) - { - return sizePeerBandwidthLimits(pblitem); - } - - return 0; -} - -/* serialise the data to the buffer */ -bool RsPeerConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsPeerNetItem *pni; - RsPeerStunItem *psi; - RsNodeGroupItem *pgi; - RsPeerServicePermissionItem *pri; - RsPeerBandwidthLimitsItem *pblitem; - - if (NULL != (pni = dynamic_cast(i))) - { - return serialiseNet(pni, data, pktsize); - } - else if (NULL != (psi = dynamic_cast(i))) - { - return serialiseStun(psi, data, pktsize); - } - else if (NULL != (pgi = dynamic_cast(i))) - { - return serialiseGroup(pgi, data, pktsize); - } - else if (NULL != (pri = dynamic_cast(i))) - { - return serialisePermissions(pri, data, pktsize); - } - else if (NULL != (pblitem = dynamic_cast(i))) - { - return serialisePeerBandwidthLimits(pblitem, data, pktsize); - } - - return false; -} - -RsItem *RsPeerConfigSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype))) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialise() Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_PEER_NET: - return deserialiseNet(data, pktsize); - case RS_PKT_SUBTYPE_PEER_STUN: - return deserialiseStun(data, pktsize); - case RS_PKT_SUBTYPE_PEER_GROUP_deprecated: - return deserialiseGroup_deprecated(data, pktsize); - case RS_PKT_SUBTYPE_NODE_GROUP: - return deserialiseGroup(data, pktsize); - case RS_PKT_SUBTYPE_PEER_PERMISSIONS: - return deserialisePermissions(data, pktsize); - case RS_PKT_SUBTYPE_PEER_BANDLIMITS: - return deserialisePeerBandwidthLimits(data, pktsize); - default: - return NULL; - } - return NULL; -} - - - -/****************************************************************************/ - -RsPeerNetItem::~RsPeerNetItem() -{ - return; -} - - - -std::ostream &RsPeerNetItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsPeerNetItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "PeerId: " << peerId.toStdString() << std::endl; - - printIndent(out, int_Indent); - out << "PgpId: " << pgpId.toStdString() << std::endl; - - printIndent(out, int_Indent); - out << "location: " << location << std::endl; - - printIndent(out, int_Indent); - out << "netMode: " << netMode << std::endl; - - printIndent(out, int_Indent); - out << "vs_disc: " << vs_disc << std::endl; - - printIndent(out, int_Indent); - out << "vs_dht: " << vs_dht << std::endl; - - printIndent(out, int_Indent); - out << "lastContact: " << lastContact << std::endl; - - printIndent(out, int_Indent); - out << "localAddrV4: " << std::endl; - localAddrV4.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "extAddrV4: " << std::endl; - extAddrV4.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "localAddrV6: " << std::endl; - localAddrV6.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "extAddrV6: " << std::endl; - extAddrV6.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "DynDNS: " << dyndns << std::endl; - - localAddrList.print(out, int_Indent); - extAddrList.print(out, int_Indent); - - printIndent(out, int_Indent); - out << "DomainAddr: " << domain_addr; - out << ":" << domain_port << std::endl; - printRsItemEnd(out, "RsPeerNetItem", indent); - return out; -} - -/*************************************************************************/ - -uint32_t RsPeerConfigSerialiser::sizeNet(RsPeerNetItem *i) -{ - uint32_t s = 8; /* header */ - s += RsPeerId::SIZE_IN_BYTES; - s += RsPgpId::SIZE_IN_BYTES; - s += GetTlvStringSize(i->location); - s += 4; /* netMode */ - s += 2; /* vs_disc */ - s += 2; /* vs_dht */ - s += 4; /* lastContact */ - - s += i->localAddrV4.TlvSize(); /* localaddr */ - s += i->extAddrV4.TlvSize(); /* remoteaddr */ - s += i->localAddrV6.TlvSize(); /* localaddr */ - s += i->extAddrV6.TlvSize(); /* remoteaddr */ - - s += GetTlvStringSize(i->dyndns); - - //add the size of the ip list - s += i->localAddrList.TlvSize(); - s += i->extAddrList.TlvSize(); - - s += GetTlvStringSize(i->domain_addr); - s += 2; /* domain_port */ - - return s; -} -#endif - void RsPeerNetItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,peerId,"peerId") ; @@ -1081,348 +181,11 @@ void RsPeerNetItem::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process(j,ctx,domain_port,"domain_port") ; } -#ifdef TO_REMOVE -bool RsPeerConfigSerialiser::serialiseNet(RsPeerNetItem *item, void *data, uint32_t *size) -{ - uint32_t tlvsize = RsPeerConfigSerialiser::sizeNet(item); - uint32_t offset = 0; - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseNet() tlvsize: " << tlvsize << std::endl; -#endif - - if(*size < tlvsize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseNet() ERROR not enough space" << std::endl; -#endif - return false; /* not enough space */ - } - - *size = tlvsize; - - bool ok = true; - - // serialise header - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseNet() Header: " << ok << std::endl; - std::cerr << "RsPeerConfigSerialiser::serialiseNet() Header test: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->peerId.serialise(data, tlvsize, offset); - ok &= item->pgpId.serialise(data, tlvsize, offset); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */ - ok &= setRawUInt32(data, tlvsize, &offset, item->netMode); /* Mandatory */ - ok &= setRawUInt16(data, tlvsize, &offset, item->vs_disc); /* Mandatory */ - ok &= setRawUInt16(data, tlvsize, &offset, item->vs_dht); /* Mandatory */ - ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */ - ok &= item->localAddrV4.SetTlv(data, tlvsize, &offset); - ok &= item->extAddrV4.SetTlv(data, tlvsize, &offset); - ok &= item->localAddrV6.SetTlv(data, tlvsize, &offset); - ok &= item->extAddrV6.SetTlv(data, tlvsize, &offset); - - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns); - - ok &= item->localAddrList.SetTlv(data, tlvsize, &offset); - ok &= item->extAddrList.SetTlv(data, tlvsize, &offset); - - // New for V0.6. - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DOMADDR, item->domain_addr); - ok &= setRawUInt16(data, tlvsize, &offset, item->domain_port); /* Mandatory */ - - if(offset != tlvsize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseNet() Size Error! " << std::endl; -#endif - ok = false; - } - - return ok; - -} - -RsPeerNetItem *RsPeerConfigSerialiser::deserialiseNet(void *data, uint32_t *size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialiseNet() rssize: " << rssize << std::endl; -#endif - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_PEER_NET != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialiseNet() ERROR Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialiseNet() ERROR not enough data" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsPeerNetItem *item = new RsPeerNetItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->peerId.deserialise(data, rssize, offset); - ok &= item->pgpId.deserialise(data, rssize, offset); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */ - ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */ - ok &= getRawUInt16(data, rssize, &offset, &(item->vs_disc)); /* Mandatory */ - ok &= getRawUInt16(data, rssize, &offset, &(item->vs_dht)); /* Mandatory */ - ok &= getRawUInt32(data, rssize, &offset, &(item->lastContact)); /* Mandatory */ - - ok &= item->localAddrV4.GetTlv(data, rssize, &offset); - ok &= item->extAddrV4.GetTlv(data, rssize, &offset); - ok &= item->localAddrV6.GetTlv(data, rssize, &offset); - ok &= item->extAddrV6.GetTlv(data, rssize, &offset); - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns); - ok &= item->localAddrList.GetTlv(data, rssize, &offset); - ok &= item->extAddrList.GetTlv(data, rssize, &offset); - - // New for V0.6. - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DOMADDR, item->domain_addr); - ok &= getRawUInt16(data, rssize, &offset, &(item->domain_port)); /* Mandatory */ - - if (offset != rssize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialiseNet() ERROR size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - return item; -} - -/****************************************************************************/ - -uint32_t RsPeerConfigSerialiser::sizePeerBandwidthLimits(RsPeerBandwidthLimitsItem *i) -{ - uint32_t s = 8; /* header */ - s += 4; // number of elements - s += i->peers.size() * (4 + 4 + RsPgpId::SIZE_IN_BYTES) ; - - return s; -} -#endif - void RsPeerBandwidthLimitsItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,peers,"peers") ; } -#ifdef TO_REMOVE -bool RsPeerConfigSerialiser::serialisePeerBandwidthLimits(RsPeerBandwidthLimitsItem *item, void *data, uint32_t *size) -{ - uint32_t tlvsize = RsPeerConfigSerialiser::sizePeerBandwidthLimits(item); - uint32_t offset = 0; - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseNet() tlvsize: " << tlvsize << std::endl; -#endif - - if(*size < tlvsize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseNet() ERROR not enough space" << std::endl; -#endif - return false; /* not enough space */ - } - - *size = tlvsize; - - bool ok = true; - - // serialise header - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseNet() Header: " << ok << std::endl; - std::cerr << "RsPeerConfigSerialiser::serialiseNet() Header test: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - ok &= setRawUInt32(data, tlvsize, &offset, item->peers.size()); /* Mandatory */ - - for(std::map::const_iterator it(item->peers.begin());it!=item->peers.end();++it) - { - ok &= it->first.serialise(data,tlvsize,offset); - - ok &= setRawUInt32(data, tlvsize, &offset, it->second.max_up_rate_kbs); /* Mandatory */ - ok &= setRawUInt32(data, tlvsize, &offset, it->second.max_dl_rate_kbs); /* Mandatory */ - } - - if(offset != tlvsize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseNet() Size Error! " << std::endl; -#endif - ok = false; - } - - return ok; - -} - -RsPeerBandwidthLimitsItem *RsPeerConfigSerialiser::deserialisePeerBandwidthLimits(void *data, uint32_t *size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialiseNet() rssize: " << rssize << std::endl; -#endif - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_PEER_BANDLIMITS != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialiseNet() ERROR Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialiseNet() ERROR not enough data" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsPeerBandwidthLimitsItem *item = new RsPeerBandwidthLimitsItem(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - uint32_t n ; - ok &= getRawUInt32(data, rssize, &offset, &n) ; - - for(uint32_t i=0;ipeers[pgpid] = p ; - } - - if (offset != rssize) - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::deserialiseNet() ERROR size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - return item; -} - -std::ostream &RsPeerBandwidthLimitsItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsPeerBandwidthLimitsItem", indent); - uint16_t int_Indent = indent + 2; - - for(std::map::const_iterator it(peers.begin());it!=peers.end();++it) - { - printIndent(out, int_Indent); - out << it->first << " : " << it->second.max_up_rate_kbs << " (up) " << it->second.max_dl_rate_kbs << " (dn)" << std::endl; - } - - printRsItemEnd(out, "RsPeerStunItem", indent); - return out; -} - - - -/****************************************************************************/ - -RsPeerStunItem::~RsPeerStunItem() -{ - return; -} - -void RsPeerStunItem::clear() -{ - stunList.TlvClear(); -} - -std::ostream &RsPeerStunItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsPeerStunItem", indent); - uint16_t int_Indent = indent + 2; - - stunList.printHex(out, int_Indent); - - printRsItemEnd(out, "RsPeerStunItem", indent); - return out; -} - -/*************************************************************************/ - -uint32_t RsPeerConfigSerialiser::sizeStun(RsPeerStunItem *i) -{ - uint32_t s = 8; /* header */ - s += i->stunList.TlvSize(); /* stunList */ - - return s; - -} -#endif - void RsPeerStunItem::serial_process(SerializeJob j,SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,stunList,"stunList") ; @@ -1463,232 +226,6 @@ RsNodeGroupItem::RsNodeGroupItem(const RsGroupInfo& g) pgpList.ids = g.peerIds; } - -#ifdef TO_REMOVE -bool RsPeerConfigSerialiser::serialiseStun(RsPeerStunItem *item, void *data, uint32_t *size) -{ - uint32_t tlvsize = RsPeerConfigSerialiser::sizeStun(item); - uint32_t offset = 0; - - if(*size < tlvsize) - return false; /* not enough space */ - - *size = tlvsize; - - bool ok = true; - - // serialise header - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseStun() Header: " << ok << std::endl; - std::cerr << "RsPeerConfigSerialiser::serialiseStun() Header: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->stunList.SetTlv(data, tlvsize, &offset); /* Mandatory */ - - if(offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseStun() Size Error! " << std::endl; -#endif - } - - return ok; - -} - -RsPeerStunItem *RsPeerConfigSerialiser::deserialiseStun(void *data, uint32_t *size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_PEER_STUN != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsPeerStunItem *item = new RsPeerStunItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= item->stunList.GetTlv(data, rssize, &offset); /* Mandatory */ - - if (offset != rssize) - { - - /* error */ - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ - -void RsNodeGroupItem::clear() -{ - id.clear(); - name.clear(); - flag = 0; - pgpList.ids.clear(); -} - -std::ostream &RsNodeGroupItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsNodeGroupItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "groupId: " << id << std::endl; - - printIndent(out, int_Indent); - out << "groupName: " << name << std::endl; - - printIndent(out, int_Indent); - out << "groupFlag: " << flag << std::endl; - - std::set::iterator it; - for (it = pgpList.ids.begin(); it != pgpList.ids.end(); ++it) { - printIndent(out, int_Indent); - out << "peerId: " << it->toStdString() << std::endl; - } - - printRsItemEnd(out, "RsNodeGroupItem", indent); - return out; -} - -/*************************************************************************/ -/* DEPRECATED CODE. SHOULD BE REMOVED WHEN EVERYONE USES THE NEW CLASS */ -/*************************************************************************/ - -RsPeerGroupItem_deprecated::RsPeerGroupItem_deprecated() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_PEER_GROUP_deprecated) -{ -} - -RsPeerGroupItem_deprecated::~RsPeerGroupItem_deprecated() -{ -} - -void RsPeerGroupItem_deprecated::clear() -{ - id.clear(); - name.clear(); - flag = 0; - pgpList.ids.clear(); -} - -std::ostream &RsPeerGroupItem_deprecated::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsPeerGroupItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "groupId: " << id << std::endl; - - printIndent(out, int_Indent); - out << "groupName: " << name << std::endl; - - printIndent(out, int_Indent); - out << "groupFlag: " << flag << std::endl; - - std::set::iterator it; - for (it = pgpList.ids.begin(); it != pgpList.ids.end(); ++it) { - printIndent(out, int_Indent); - out << "peerId: " << it->toStdString() << std::endl; - } - - printRsItemEnd(out, "RsPeerGroupItem", indent); - return out; -} - -RsPeerGroupItem_deprecated *RsPeerConfigSerialiser::deserialiseGroup_deprecated(void *data, uint32_t *size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_PEER_GROUP_deprecated != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsPeerGroupItem_deprecated *item = new RsPeerGroupItem_deprecated(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - uint32_t version; - ok &= getRawUInt32(data, rssize, &offset, &version); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_KEY, item->id); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name); - ok &= getRawUInt32(data, rssize, &offset, &(item->flag)); - ok &= item->pgpList.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - return item; -} -/*************************************************************************/ - -uint32_t RsPeerConfigSerialiser::sizeGroup(RsNodeGroupItem *i) -{ - uint32_t s = 8; /* header */ - s += 4; /* version */ - s += RsNodeGroupId::serial_size(); - s += GetTlvStringSize(i->name); - s += 4; /* flag */ - s += i->pgpList.TlvSize(); - return s; -} - -#endif - void RsNodeGroupItem::serial_process(SerializeJob j,SerializeContext& ctx) { uint32_t v=0 ; @@ -1700,128 +237,6 @@ void RsNodeGroupItem::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process(j,ctx,pgpList,"pgpList") ; } -#ifdef TO_REMOVE -bool RsPeerConfigSerialiser::serialiseGroup(RsNodeGroupItem *item, void *data, uint32_t *size) -{ - uint32_t tlvsize = RsPeerConfigSerialiser::sizeGroup(item); - uint32_t offset = 0; - - if(*size < tlvsize) - return false; /* not enough space */ - - *size = tlvsize; - - bool ok = true; - - // serialise header - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseGroup() Header: " << ok << std::endl; - std::cerr << "RsPeerConfigSerialiser::serialiseGroup() Header: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, 0); - ok &= item->id.serialise(data, tlvsize, offset); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name); - ok &= setRawUInt32(data, tlvsize, &offset, item->flag); - ok &= item->pgpList.SetTlv(data, tlvsize, &offset); - - if(offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseGroup() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsNodeGroupItem *RsPeerConfigSerialiser::deserialiseGroup(void *data, uint32_t *size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_NODE_GROUP != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsNodeGroupItem *item = new RsNodeGroupItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - uint32_t version; - ok &= getRawUInt32(data, rssize, &offset, &version); - ok &= item->id.deserialise(data, rssize, offset); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name); - ok &= getRawUInt32(data, rssize, &offset, &(item->flag)); - ok &= item->pgpList.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - return item; -} - -/**************************************************************/ - -std::ostream& RsPeerServicePermissionItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsPeerServicePermissionItem", indent); - uint16_t int_Indent = indent + 2; - - for(uint32_t i=0;ipgp_ids.size();++j) - { - s += RsPgpId::SIZE_IN_BYTES ;//GetTlvStringSize(i->pgp_ids[j]) ; - s += 4; /* flag */ - } - - return s; -} -#endif - void RsPeerServicePermissionItem::serial_process(SerializeJob j,SerializeContext& ctx) { // We need to hack this because of backward compatibility. The correct way to do it would be: @@ -1850,289 +265,3 @@ void RsPeerServicePermissionItem::serial_process(SerializeJob j,SerializeContext } } -#ifdef TO_REMOVE -bool RsPeerConfigSerialiser::serialisePermissions(RsPeerServicePermissionItem *item, void *data, uint32_t *size) -{ - uint32_t tlvsize = RsPeerConfigSerialiser::sizePermissions(item); - uint32_t offset = 0; - - if(*size < tlvsize) - return false; /* not enough space */ - - *size = tlvsize; - - bool ok = true; - - // serialise header - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialiseGroup() Header: " << ok << std::endl; - std::cerr << "RsPeerConfigSerialiser::serialiseGroup() Header: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, item->pgp_ids.size()); - - for(uint32_t i=0;ipgp_ids.size();++i) - { - ok &= item->pgp_ids[i].serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, item->service_flags[i].toUInt32()); - } - - if(offset != tlvsize) - { - ok = false; - std::cerr << "(EE) Item size ERROR in RsPeerServicePermissionItem!" << std::endl; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsPeerConfigSerialiser::serialisePermissions() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsPeerServicePermissionItem *RsPeerConfigSerialiser::deserialisePermissions(void *data, uint32_t *size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_PEER_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_PEER_PERMISSIONS != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsPeerServicePermissionItem *item = new RsPeerServicePermissionItem ; - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - uint32_t s; - ok &= getRawUInt32(data, rssize, &offset, &s); - item->pgp_ids.resize(s) ; - item->service_flags.resize(s) ; - - for(uint32_t i=0;ipgp_ids[i].deserialise(data, rssize, offset) ; - ok &= getRawUInt32(data, rssize, &offset, &flags); - - item->service_flags[i] = ServicePermissionFlags(flags) ; - } - - if (offset != rssize) - { - /* error */ - std::cerr << "(EE) Item size ERROR in RsPeerServicePermissionItem!" << std::endl; - delete item; - return NULL; - } - - return item; -} - - - -/****************************************************************************/ - - -RsCacheConfig::~RsCacheConfig() -{ - return; -} - -void RsCacheConfig::clear() -{ - pid.clear(); - cachetypeid = 0; - cachesubid = 0; - path = ""; - name = ""; - hash.clear() ; - size = 0; - recvd = 0; - -} - -std::ostream &RsCacheConfig::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsCacheConfig", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); //indent - out << "pid: " << pid << std::endl; // display value of peerid - - printIndent(out, int_Indent); //indent - out << "cacheid: " << cachetypeid << ":" << cachesubid << std::endl; // display value of cacheid - - printIndent(out, int_Indent); - out << "path: " << path << std::endl; // display value of path - - printIndent(out, int_Indent); - out << "name: " << name << std::endl; // display value of name - - printIndent(out, int_Indent); - out << "hash: " << hash << std::endl; // display value of hash - - printIndent(out, int_Indent); - out << "size: " << size << std::endl; // display value of size - - printIndent(out, int_Indent); - out << "recvd: " << recvd << std::endl; // display value of recvd - - printRsItemEnd(out, "RsCacheConfig", indent); // end of 'WRITE' check - return out; -} - -/**************************************************************************/ - - -RsCacheConfigSerialiser::~RsCacheConfigSerialiser() -{ - return; -} - -uint32_t RsCacheConfigSerialiser::size(RsItem *i) -{ - RsCacheConfig *item = (RsCacheConfig *) i; - - uint32_t s = 8; // to store calculated size, initiailize with size of header - - - s += item->pid.serial_size(); - s += 2; /* cachetypeid */ - s += 2; /* cachesubid */ - s += GetTlvStringSize(item->path); - s += GetTlvStringSize(item->name); - s += item->hash.serial_size(); - s += 8; /* size */ - s += 4; /* recvd */ - - return s; -} - -bool RsCacheConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *size) -{ - RsCacheConfig *item = (RsCacheConfig *) i; - uint32_t tlvsize = RsCacheConfigSerialiser::size(item); - uint32_t offset = 0; - - if(*size < tlvsize) - return false; /* not enough space */ - - *size = tlvsize; - - bool ok = true; - - ok &=setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsCacheConfigSerialiser::serialise() Header: " << ok << std::endl; - std::cerr << "RsCacheConfigSerialiser::serialise() Size: " << size << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add the mandatory parts first */ - - ok &= item->pid.serialise(data, tlvsize, offset) ; - ok &= setRawUInt16(data, tlvsize, &offset, item->cachetypeid); - ok &= setRawUInt16(data, tlvsize, &offset, item->cachesubid); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PATH, item->path); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name); - ok &= item->hash.serialise(data, tlvsize, offset) ; - ok &= setRawUInt64(data, tlvsize, &offset, item->size); - ok &= setRawUInt32(data, tlvsize, &offset, item->recvd); - - if (offset !=tlvsize) - { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsConfigSerialiser::serialisertransfer() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsItem *RsCacheConfigSerialiser::deserialise(void *data, uint32_t *size) -{/* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset; - offset = 0; - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_CACHE_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_DEFAULT != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - /* ready to load */ - RsCacheConfig *item = new RsCacheConfig(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - - ok &= item->pid.deserialise(data, rssize, offset) ; - ok &= getRawUInt16(data, rssize, &offset, &(item->cachetypeid)); - ok &= getRawUInt16(data, rssize, &offset, &(item->cachesubid)); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PATH, item->path); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name); - ok &= item->hash.deserialise(data, rssize, offset) ; - ok &= getRawUInt64(data, rssize, &offset, &(item->size)); - ok &= getRawUInt32(data, rssize, &offset, &(item->recvd)); - - - if (offset != rssize) - { - - /* error */ - delete item; - return NULL; - } - - return item; -} - - -#endif - - - From 0d7df568b49601d80dfa01946d1971a803cb43cc Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 24 Apr 2017 22:47:08 +0200 Subject: [PATCH 47/94] moved rsconfigitems and rshistoryitems to rsitems/ --- libretroshare/src/chat/p3chatservice.cc | 2 +- libretroshare/src/dht/p3bitdht_relay.cc | 2 +- libretroshare/src/ft/ftcontroller.cc | 2 +- libretroshare/src/ft/ftcontroller.h | 2 +- libretroshare/src/ft/ftextralist.cc | 2 +- libretroshare/src/grouter/p3grouter.cc | 2 +- libretroshare/src/libretroshare.pro | 8 ++++---- libretroshare/src/pqi/authgpg.cc | 2 +- libretroshare/src/pqi/authssl.cc | 2 +- libretroshare/src/pqi/p3cfgmgr.cc | 2 +- libretroshare/src/pqi/p3historymgr.cc | 4 ++-- libretroshare/src/pqi/p3historymgr.h | 2 +- libretroshare/src/pqi/p3linkmgr.cc | 3 ++- libretroshare/src/pqi/p3netmgr.cc | 3 ++- libretroshare/src/pqi/p3peermgr.cc | 2 +- .../src/{serialiser => rsitems}/rsconfigitems.cc | 2 +- libretroshare/src/{serialiser => rsitems}/rsconfigitems.h | 0 .../src/{serialiser => rsitems}/rshistoryitems.cc | 5 +++-- .../src/{serialiser => rsitems}/rshistoryitems.h | 2 +- libretroshare/src/serialiser/rspluginitems.h | 2 +- libretroshare/src/services/p3banlist.cc | 5 +++-- libretroshare/src/services/p3gxsreputation.cc | 3 ++- libretroshare/src/services/p3idservice.cc | 2 +- libretroshare/src/services/p3msgservice.cc | 3 ++- 24 files changed, 35 insertions(+), 29 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsconfigitems.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rsconfigitems.h (100%) rename libretroshare/src/{serialiser => rsitems}/rshistoryitems.cc (95%) rename libretroshare/src/{serialiser => rsitems}/rshistoryitems.h (94%) diff --git a/libretroshare/src/chat/p3chatservice.cc b/libretroshare/src/chat/p3chatservice.cc index eb421ac31..453ec7df1 100644 --- a/libretroshare/src/chat/p3chatservice.cc +++ b/libretroshare/src/chat/p3chatservice.cc @@ -42,7 +42,7 @@ #include "services/p3idservice.h" #include "chat/p3chatservice.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" /**** * #define CHAT_DEBUG 1 diff --git a/libretroshare/src/dht/p3bitdht_relay.cc b/libretroshare/src/dht/p3bitdht_relay.cc index d71f3e7c5..d846e7691 100644 --- a/libretroshare/src/dht/p3bitdht_relay.cc +++ b/libretroshare/src/dht/p3bitdht_relay.cc @@ -29,7 +29,7 @@ #include "tcponudp/udprelay.h" #include "bitdht/bdstddht.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" /*********************************************************************************************** diff --git a/libretroshare/src/ft/ftcontroller.cc b/libretroshare/src/ft/ftcontroller.cc index 13bafa5f0..fad8642fa 100644 --- a/libretroshare/src/ft/ftcontroller.cc +++ b/libretroshare/src/ft/ftcontroller.cc @@ -60,7 +60,7 @@ #include "retroshare/rsiface.h" #include "retroshare/rspeers.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include #include /* for (u)sleep() */ #include diff --git a/libretroshare/src/ft/ftcontroller.h b/libretroshare/src/ft/ftcontroller.h index 6f41c3dc8..edeb8d82f 100644 --- a/libretroshare/src/ft/ftcontroller.h +++ b/libretroshare/src/ft/ftcontroller.h @@ -53,7 +53,7 @@ class p3ServiceControl; #include "pqi/p3cfgmgr.h" #include "retroshare/rsfiles.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include diff --git a/libretroshare/src/ft/ftextralist.cc b/libretroshare/src/ft/ftextralist.cc index 8538a46a9..7548d421c 100644 --- a/libretroshare/src/ft/ftextralist.cc +++ b/libretroshare/src/ft/ftextralist.cc @@ -30,7 +30,7 @@ #include #include #include "ft/ftextralist.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "util/rsdir.h" #include #include /* for (u)sleep() */ diff --git a/libretroshare/src/grouter/p3grouter.cc b/libretroshare/src/grouter/p3grouter.cc index 5f2b6e7d0..f14af4412 100644 --- a/libretroshare/src/grouter/p3grouter.cc +++ b/libretroshare/src/grouter/p3grouter.cc @@ -186,7 +186,7 @@ #include "util/rsrandom.h" #include "util/rsprint.h" #include "util/rsmemory.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "services/p3idservice.h" #include "turtle/p3turtle.h" #include "gxs/rsgixs.h" diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index e6f1a4ef4..8a633c1a7 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -456,8 +456,8 @@ HEADERS += rsitems/itempriorities.h \ serialiser/rsbaseserial.h \ rsitems/rsfiletransferitems.h \ serialiser/rsserviceserialiser.h \ - serialiser/rsconfigitems.h \ - serialiser/rshistoryitems.h \ + rsitems/rsconfigitems.h \ + rsitems/rshistoryitems.h \ rsitems/rsmsgitems.h \ serialiser/rsserial.h \ rsitems/rsserviceids.h \ @@ -610,8 +610,8 @@ SOURCES += plugins/pluginmanager.cc \ SOURCES += serialiser/rsbaseserial.cc \ rsitems/rsfiletransferitems.cc \ serialiser/rsserviceserialiser.cc \ - serialiser/rsconfigitems.cc \ - serialiser/rshistoryitems.cc \ + rsitems/rsconfigitems.cc \ + rsitems/rshistoryitems.cc \ rsitems/rsmsgitems.cc \ serialiser/rsserial.cc \ serialiser/rsstatusitems.cc \ diff --git a/libretroshare/src/pqi/authgpg.cc b/libretroshare/src/pqi/authgpg.cc index 38756476c..1e20d6b85 100644 --- a/libretroshare/src/pqi/authgpg.cc +++ b/libretroshare/src/pqi/authgpg.cc @@ -41,7 +41,7 @@ #include #include #include -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #define LIMIT_CERTIFICATE_SIZE 1 #define MAX_CERTIFICATE_SIZE 10000 diff --git a/libretroshare/src/pqi/authssl.cc b/libretroshare/src/pqi/authssl.cc index 4191e0b4f..ccc176908 100644 --- a/libretroshare/src/pqi/authssl.cc +++ b/libretroshare/src/pqi/authssl.cc @@ -37,7 +37,7 @@ #include "pqinetwork.h" #include "authgpg.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "util/rsdir.h" #include "util/rsstring.h" diff --git a/libretroshare/src/pqi/p3cfgmgr.cc b/libretroshare/src/pqi/p3cfgmgr.cc index 5f9934d57..3266f68d4 100644 --- a/libretroshare/src/pqi/p3cfgmgr.cc +++ b/libretroshare/src/pqi/p3cfgmgr.cc @@ -35,7 +35,7 @@ #include #include "util/rsstring.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" /* #define CONFIG_DEBUG 1 diff --git a/libretroshare/src/pqi/p3historymgr.cc b/libretroshare/src/pqi/p3historymgr.cc index 5739ff94a..72a2640ec 100644 --- a/libretroshare/src/pqi/p3historymgr.cc +++ b/libretroshare/src/pqi/p3historymgr.cc @@ -26,8 +26,8 @@ #include #include "p3historymgr.h" -#include "serialiser/rshistoryitems.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rshistoryitems.h" +#include "rsitems/rsconfigitems.h" #include "retroshare/rsiface.h" #include "retroshare/rspeers.h" #include "rsitems/rsmsgitems.h" diff --git a/libretroshare/src/pqi/p3historymgr.h b/libretroshare/src/pqi/p3historymgr.h index 98d7b6eed..3f3c9a6f1 100644 --- a/libretroshare/src/pqi/p3historymgr.h +++ b/libretroshare/src/pqi/p3historymgr.h @@ -29,7 +29,7 @@ #include #include -#include "serialiser/rshistoryitems.h" +#include "rsitems/rshistoryitems.h" #include "retroshare/rshistory.h" #include "pqi/p3cfgmgr.h" diff --git a/libretroshare/src/pqi/p3linkmgr.cc b/libretroshare/src/pqi/p3linkmgr.cc index 26a27dc45..39424a21b 100644 --- a/libretroshare/src/pqi/p3linkmgr.cc +++ b/libretroshare/src/pqi/p3linkmgr.cc @@ -41,7 +41,8 @@ #include "util/rsprint.h" #include "util/rsdebug.h" #include "util/rsstring.h" -#include "serialiser/rsconfigitems.h" + +#include "rsitems/rsconfigitems.h" #include "retroshare/rsiface.h" #include "retroshare/rspeers.h" diff --git a/libretroshare/src/pqi/p3netmgr.cc b/libretroshare/src/pqi/p3netmgr.cc index 1cbabb75c..acfa32852 100644 --- a/libretroshare/src/pqi/p3netmgr.cc +++ b/libretroshare/src/pqi/p3netmgr.cc @@ -42,7 +42,8 @@ struct RsLog::logInfo p3netmgrzoneInfo = {RsLog::Default, "p3netmgr"}; #define p3netmgrzone &p3netmgrzoneInfo -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" + #include "retroshare/rsiface.h" #include "retroshare/rsconfig.h" #include "retroshare/rsbanlist.h" diff --git a/libretroshare/src/pqi/p3peermgr.cc b/libretroshare/src/pqi/p3peermgr.cc index d26c4a950..5ae948d86 100644 --- a/libretroshare/src/pqi/p3peermgr.cc +++ b/libretroshare/src/pqi/p3peermgr.cc @@ -42,7 +42,7 @@ #include "util/rsstring.h" #include "util/rsdebug.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "retroshare/rsiface.h" // Needed for rsicontrol (should remove this dependancy) #include "retroshare/rspeers.h" // Needed for Group Parameters. diff --git a/libretroshare/src/serialiser/rsconfigitems.cc b/libretroshare/src/rsitems/rsconfigitems.cc similarity index 99% rename from libretroshare/src/serialiser/rsconfigitems.cc rename to libretroshare/src/rsitems/rsconfigitems.cc index 856294ca3..4ba94a8bf 100644 --- a/libretroshare/src/serialiser/rsconfigitems.cc +++ b/libretroshare/src/rsitems/rsconfigitems.cc @@ -25,7 +25,7 @@ */ #include "serialiser/rsbaseserial.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "retroshare/rspeers.h" // Needed for RsGroupInfo. /*** diff --git a/libretroshare/src/serialiser/rsconfigitems.h b/libretroshare/src/rsitems/rsconfigitems.h similarity index 100% rename from libretroshare/src/serialiser/rsconfigitems.h rename to libretroshare/src/rsitems/rsconfigitems.h diff --git a/libretroshare/src/serialiser/rshistoryitems.cc b/libretroshare/src/rsitems/rshistoryitems.cc similarity index 95% rename from libretroshare/src/serialiser/rshistoryitems.cc rename to libretroshare/src/rsitems/rshistoryitems.cc index 6c05e9afb..eb50bf15e 100644 --- a/libretroshare/src/serialiser/rshistoryitems.cc +++ b/libretroshare/src/rsitems/rshistoryitems.cc @@ -23,10 +23,11 @@ * */ -#include "serialiser/rshistoryitems.h" +#include "rsitems/rshistoryitems.h" +#include "rsitems/rsconfigitems.h" + #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" -#include "serialiser/rsconfigitems.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/serialiser/rshistoryitems.h b/libretroshare/src/rsitems/rshistoryitems.h similarity index 94% rename from libretroshare/src/serialiser/rshistoryitems.h rename to libretroshare/src/rsitems/rshistoryitems.h index ffc5b571c..27a387f60 100644 --- a/libretroshare/src/serialiser/rshistoryitems.h +++ b/libretroshare/src/rsitems/rshistoryitems.h @@ -28,7 +28,7 @@ #include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "retroshare/rstypes.h" #include "serialization/rsserializer.h" diff --git a/libretroshare/src/serialiser/rspluginitems.h b/libretroshare/src/serialiser/rspluginitems.h index ed2bda137..02b64fc54 100644 --- a/libretroshare/src/serialiser/rspluginitems.h +++ b/libretroshare/src/serialiser/rspluginitems.h @@ -27,7 +27,7 @@ #pragma once #include "serialiser/rsserial.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "serialiser/rsbaseserial.h" #if 0 diff --git a/libretroshare/src/services/p3banlist.cc b/libretroshare/src/services/p3banlist.cc index bf72ea815..800fe697c 100644 --- a/libretroshare/src/services/p3banlist.cc +++ b/libretroshare/src/services/p3banlist.cc @@ -30,11 +30,12 @@ #include "util/rsnet.h" #include "services/p3banlist.h" -#include "rsitems/rsbanlistitems.h" -#include "serialiser/rsconfigitems.h" #include "retroshare/rsdht.h" #include "retroshare/rsbanlist.h" +#include "rsitems/rsbanlistitems.h" +#include "rsitems/rsconfigitems.h" + #include #include diff --git a/libretroshare/src/services/p3gxsreputation.cc b/libretroshare/src/services/p3gxsreputation.cc index 609382444..d2ad1b9da 100644 --- a/libretroshare/src/services/p3gxsreputation.cc +++ b/libretroshare/src/services/p3gxsreputation.cc @@ -29,8 +29,9 @@ #include "retroshare/rspeers.h" #include "services/p3gxsreputation.h" + #include "rsitems/rsgxsreputationitems.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include diff --git a/libretroshare/src/services/p3idservice.cc b/libretroshare/src/services/p3idservice.cc index 53b922327..c173dba8a 100644 --- a/libretroshare/src/services/p3idservice.cc +++ b/libretroshare/src/services/p3idservice.cc @@ -28,7 +28,7 @@ #include "services/p3idservice.h" #include "pgp/pgpauxutils.h" #include "serialiser/rsgxsiditems.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "retroshare/rsgxsflags.h" #include "util/rsrandom.h" #include "util/rsstring.h" diff --git a/libretroshare/src/services/p3msgservice.cc b/libretroshare/src/services/p3msgservice.cc index a3aacfc7b..29fad5319 100644 --- a/libretroshare/src/services/p3msgservice.cc +++ b/libretroshare/src/services/p3msgservice.cc @@ -41,7 +41,8 @@ #include "pgp/pgpkeyutil.h" #include "rsserver/p3face.h" -#include "serialiser/rsconfigitems.h" + +#include "rsitems/rsconfigitems.h" #include "grouter/p3grouter.h" #include "grouter/groutertypes.h" From 77e809ea4b9f4a9e6e7b3cc36b016a163ecc1f74 Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 25 Apr 2017 21:21:46 +0200 Subject: [PATCH 48/94] switched GRouter to new serialization --- libretroshare/src/grouter/grouteritems.cc | 262 +++++++++++++++--- libretroshare/src/grouter/grouteritems.h | 161 +++-------- libretroshare/src/grouter/p3grouter.cc | 67 +++-- libretroshare/src/pqi/pqistore.cc | 2 +- libretroshare/src/serialiser/rsserial.h | 2 +- .../src/serialization/rsserializer.cc | 43 ++- .../src/serialization/rsserializer.h | 1 + 7 files changed, 343 insertions(+), 195 deletions(-) diff --git a/libretroshare/src/grouter/grouteritems.cc b/libretroshare/src/grouter/grouteritems.cc index 3f500d615..c48dbc134 100644 --- a/libretroshare/src/grouter/grouteritems.cc +++ b/libretroshare/src/grouter/grouteritems.cc @@ -1,65 +1,71 @@ +#include "util/rsprint.h" #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" #include "grouteritems.h" -/**********************************************************************************************/ -/* SERIALISATION */ -/**********************************************************************************************/ - -bool RsGRouterItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const -{ - tlvsize = serial_size() ; - offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsFileTransferItem::serialise_header(): ERROR. Not enough size!" << std::endl; - return false ; - } -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileItemSerialiser::serialiseData() Header: " << ok << std::endl; -#endif - offset += 8; - - return true ; -} - /**********************************************************************************************/ /* SERIALISER STUFF */ /**********************************************************************************************/ -RsItem *RsGRouterSerialiser::deserialise(void *data, uint32_t *pktsize) +RsItem *RsGRouterSerialiser::create_item(uint16_t service_id,uint8_t subtype) const { - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if(RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_GROUTER != getRsItemService(rstype)) - { + if(RS_SERVICE_TYPE_GROUTER != service_id) return NULL; /* wrong type */ - } - switch(getRsItemSubType(rstype)) + switch(subtype) { - case RS_PKT_SUBTYPE_GROUTER_DATA: return deserialise_RsGRouterGenericDataItem (data, *pktsize); - case RS_PKT_SUBTYPE_GROUTER_TRANSACTION_CHUNK: return deserialise_RsGRouterTransactionChunkItem(data, *pktsize); - case RS_PKT_SUBTYPE_GROUTER_TRANSACTION_ACKN: return deserialise_RsGRouterTransactionAcknItem (data, *pktsize); - case RS_PKT_SUBTYPE_GROUTER_SIGNED_RECEIPT: return deserialise_RsGRouterSignedReceiptItem (data, *pktsize); - case RS_PKT_SUBTYPE_GROUTER_MATRIX_CLUES: return deserialise_RsGRouterMatrixCluesItem (data, *pktsize); - case RS_PKT_SUBTYPE_GROUTER_MATRIX_TRACK: return deserialise_RsGRouterMatrixTrackItem (data, *pktsize); - case RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST: return deserialise_RsGRouterMatrixFriendListItem(data, *pktsize); - case RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO: return deserialise_RsGRouterRoutingInfoItem (data, *pktsize); + case RS_PKT_SUBTYPE_GROUTER_DATA: return new RsGRouterGenericDataItem (); + case RS_PKT_SUBTYPE_GROUTER_TRANSACTION_CHUNK: return new RsGRouterTransactionChunkItem(); + case RS_PKT_SUBTYPE_GROUTER_TRANSACTION_ACKN: return new RsGRouterTransactionAcknItem (); + case RS_PKT_SUBTYPE_GROUTER_SIGNED_RECEIPT: return new RsGRouterSignedReceiptItem (); + case RS_PKT_SUBTYPE_GROUTER_MATRIX_CLUES: return new RsGRouterMatrixCluesItem (); + case RS_PKT_SUBTYPE_GROUTER_MATRIX_TRACK: return new RsGRouterMatrixTrackItem (); + case RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST: return new RsGRouterMatrixFriendListItem(); + case RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO: return new RsGRouterRoutingInfoItem (); default: - std::cerr << "RsGRouterSerialiser::deserialise(): Could not de-serialise item. SubPacket id = " << std::hex << getRsItemSubType(rstype) << " id = " << rstype << std::dec << std::endl; return NULL; } - return NULL; } + +void RsGRouterTransactionChunkItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,propagation_id,"propagation_id") ; + RsTypeSerializer::serial_process(j,ctx,chunk_start ,"chunk_start") ; + RsTypeSerializer::serial_process(j,ctx,chunk_size ,"chunk_size") ; + RsTypeSerializer::serial_process(j,ctx,total_size ,"total_size") ; + + // Hack for backward compatibility (the chunk size is not directly next to the chunk data) + + if(j == RsItem::DESERIALIZE) + { + if(chunk_size > ctx.mSize || ctx.mOffset > ctx.mSize - chunk_size) // better than if(chunk_size + offset > size) + { + std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl; + ctx.mOk = false ; + return ; + } + if( NULL == (chunk_data = (uint8_t*)rs_malloc(chunk_size))) + { + ctx.mOk = false ; + return ; + } + + memcpy(chunk_data,&((uint8_t*)ctx.mData)[ctx.mOffset],chunk_size) ; + ctx.mOffset += chunk_size ; + } + else if(j== RsItem::SERIALIZE) + { + memcpy(&((uint8_t*)ctx.mData)[ctx.mOffset],chunk_data,chunk_size) ; + ctx.mOffset += chunk_size ; + } + else if(j== RsItem::SIZE_ESTIMATE) + ctx.mOffset += chunk_size ; + else + std::cerr << " [Binary data] " << ", length=" << chunk_size << " data=" << RsUtil::BinToHex((uint8_t*)chunk_data,std::min(50u,chunk_size)) << ((chunk_size>50)?"...":"") << std::endl; + +} +#ifdef TO_REMOVE RsGRouterTransactionChunkItem *RsGRouterSerialiser::deserialise_RsGRouterTransactionChunkItem(void *data, uint32_t tlvsize) const { uint32_t offset = 8; // skip the header @@ -104,6 +110,14 @@ RsGRouterTransactionChunkItem *RsGRouterSerialiser::deserialise_RsGRouterTransac return item; } +#endif + +void RsGRouterTransactionAcknItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,propagation_id,"propagation_id") ; +} + +#ifdef TO_REMOVE RsGRouterTransactionAcknItem *RsGRouterSerialiser::deserialise_RsGRouterTransactionAcknItem(void *data, uint32_t tlvsize) const { uint32_t offset = 8; // skip the header @@ -124,6 +138,41 @@ RsGRouterTransactionAcknItem *RsGRouterSerialiser::deserialise_RsGRouterTransact return item; } +#endif + +void RsGRouterGenericDataItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,routing_id,"routing_id") ; + RsTypeSerializer::serial_process (j,ctx,destination_key,"destination_key") ; + RsTypeSerializer::serial_process(j,ctx,service_id,"service_id") ; + + RsTypeSerializer::TlvMemBlock_proxy prox(data_bytes,data_size) ; + + RsTypeSerializer::serial_process(j,ctx,prox,"data") ; + + if(ctx.mFlags & RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE) + return ; + + RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; + RsTypeSerializer::serial_process(j,ctx,duplication_factor,"duplication_factor") ; + RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; + + if(j == RsItem::DESERIALIZE) // make sure the duplication factor is not altered by friends. In the worst case, the item will duplicate a bit more. + { + if(duplication_factor < 1) + { + duplication_factor = 1 ; + std::cerr << "(II) correcting GRouter item duplication factor from 0 to 1, to ensure backward compat." << std::endl; + } + if(duplication_factor > GROUTER_MAX_DUPLICATION_FACTOR) + { + std::cerr << "(WW) correcting GRouter item duplication factor of " << duplication_factor << ". This is very unexpected." << std::endl; + duplication_factor = GROUTER_MAX_DUPLICATION_FACTOR ; + } + } +} + +#ifdef TO_REMOVE RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header @@ -191,7 +240,23 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI return item; } +#endif +void RsGRouterSignedReceiptItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,routing_id,"routing_id") ; + RsTypeSerializer::serial_process (j,ctx,flags,"flags") ; + RsTypeSerializer::serial_process (j,ctx,destination_key,"destination_key") ; + RsTypeSerializer::serial_process (j,ctx,service_id,"service_id") ; + RsTypeSerializer::serial_process (j,ctx,data_hash,"data_hash") ; + + if(ctx.mFlags & RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE) + return ; + + RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; +} + +#ifdef TO_REMOVE RsGRouterSignedReceiptItem *RsGRouterSerialiser::deserialise_RsGRouterSignedReceiptItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header @@ -216,7 +281,76 @@ RsGRouterSignedReceiptItem *RsGRouterSerialiser::deserialise_RsGRouterSignedRece return item; } +#endif +void RsGRouterRoutingInfoItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,peerId,"peerId") ; + RsTypeSerializer::serial_process(j,ctx,data_status,"data_status") ; + RsTypeSerializer::serial_process(j,ctx,tunnel_status,"tunnel_status") ; + RsTypeSerializer::serial_process (j,ctx,received_time_TS,"received_time_TS") ; + RsTypeSerializer::serial_process (j,ctx,last_sent_TS,"last_sent_TS") ; + + RsTypeSerializer::serial_process (j,ctx,last_tunnel_request_TS,"last_tunnel_request_TS") ; + RsTypeSerializer::serial_process(j,ctx,sending_attempts,"sending_attempts") ; + + RsTypeSerializer::serial_process(j,ctx,client_id,"client_id") ; + RsTypeSerializer::serial_process (j,ctx,item_hash,"item_hash") ; + RsTypeSerializer::serial_process (j,ctx,tunnel_hash,"tunnel_hash") ; + RsTypeSerializer::serial_process(j,ctx,routing_flags,"routing_flags") ; + + RsTypeSerializer::serial_process(j,ctx,incoming_routes,"incoming_routes") ; + + // Hack for backward compatibility. Normally we should need a single commandline to serialise/deserialise a single item here. + // But the full item is serialised, so we need the header. + + if(j == RsItem::DESERIALIZE) + { + data_item = new RsGRouterGenericDataItem() ; + + ctx.mOffset += 8 ; + data_item->serial_process(j,ctx) ; + + if(ctx.mOffset < ctx.mSize) + { + receipt_item = new RsGRouterSignedReceiptItem(); + + ctx.mOffset += 8 ; + receipt_item->serial_process(j,ctx) ; + } + else + receipt_item = NULL ; + } + else if(j == RsItem::SERIALIZE) + { + uint32_t remaining_size = ctx.mSize - ctx.mOffset; + ctx.mOk = ctx.mOk && RsGRouterSerialiser().serialise(data_item,ctx.mData,&remaining_size) ; + ctx.mOffset += RsGRouterSerialiser().size(data_item) ; + + if(receipt_item != NULL) + { + remaining_size = ctx.mSize - ctx.mOffset; + ctx.mOk = ctx.mOk && RsGRouterSerialiser().serialise(data_item,ctx.mData,&remaining_size); + ctx.mOffset += RsGRouterSerialiser().size(data_item) ; + } + } + else if(j == RsItem::PRINT) + { + std::cerr << " [Serialized data] " << std::endl; + + if(receipt_item != NULL) + std::cerr << " [Receipt item ]" << std::endl; + } + else if(j == RsItem::SIZE_ESTIMATE) + { + ctx.mOffset += RsGRouterSerialiser().size(data_item) ; + + if(receipt_item != NULL) + ctx.mOffset += RsGRouterSerialiser().size(receipt_item) ; + } +} + +#ifdef TO_REMOVE RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header @@ -274,6 +408,14 @@ RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoI return item; } +#endif + +void RsGRouterMatrixFriendListItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,reverse_friend_indices,"reverse_friend_indices") ; +} + +#ifdef TO_REMOVE RsGRouterMatrixFriendListItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header @@ -299,7 +441,16 @@ RsGRouterMatrixFriendListItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixF return item; } +#endif +void RsGRouterMatrixTrackItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,provider_id,"provider_id") ; + RsTypeSerializer::serial_process(j,ctx,message_id,"message_id") ; + RsTypeSerializer::serial_process(j,ctx,time_stamp,"time_stamp") ; +} + +#ifdef TO_REMOVE RsGRouterMatrixTrackItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixTrackItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header @@ -321,6 +472,22 @@ RsGRouterMatrixTrackItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixTrackI return item; } +#endif + +void RsGRouterMatrixCluesItem::serial_process(SerializeJob j,SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,destination_key,"destination_key") ; + RsTypeSerializer::serial_process(j,ctx,clues,"clues") ; +} + +template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,RoutingMatrixHitEntry& s,const std::string& name) +{ + RsTypeSerializer::serial_process(j,ctx,s.friend_id,name+":friend_id") ; + RsTypeSerializer::serial_process (j,ctx,s.weight,name+":weight") ; + RsTypeSerializer::serial_process (j,ctx,s.time_stamp,name+":time_stamp") ; +} + +#ifdef TO_REMOVE RsGRouterMatrixCluesItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header @@ -356,6 +523,8 @@ RsGRouterMatrixCluesItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesI return item; } +#endif + RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const { RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem ; @@ -393,6 +562,8 @@ RsGRouterSignedReceiptItem *RsGRouterSignedReceiptItem::duplicate() const return item ; } + +#ifdef TO_REMOVE uint32_t RsGRouterGenericDataItem::serial_size() const { uint32_t s = 8 ; // header @@ -896,3 +1067,4 @@ std::ostream& RsGRouterMatrixFriendListItem::print(std::ostream& o, uint16_t) return o ; } +#endif diff --git a/libretroshare/src/grouter/grouteritems.h b/libretroshare/src/grouter/grouteritems.h index af78866c0..7c69d4718 100644 --- a/libretroshare/src/grouter/grouteritems.h +++ b/libretroshare/src/grouter/grouteritems.h @@ -63,14 +63,7 @@ class RsGRouterItem: public RsItem virtual ~RsGRouterItem() {} - virtual bool serialise(void *data,uint32_t& size) const = 0 ; - virtual uint32_t serial_size() const = 0 ; - virtual void clear() = 0 ; - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0; - - protected: - bool serialise_header(void *data, uint32_t& pktsize, uint32_t& tlvsize, uint32_t& offset) const; }; /***********************************************************************************/ @@ -100,14 +93,11 @@ public: RsGRouterAbstractMsgItem(uint8_t pkt_subtype) : RsGRouterItem(pkt_subtype) {} virtual ~RsGRouterAbstractMsgItem() {} - virtual uint32_t signed_data_size() const = 0 ; - virtual bool serialise_signed_data(void *data,uint32_t size) const = 0 ; - 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 + uint32_t flags ; // packet was delivered, not delivered, bounced, etc }; class RsGRouterGenericDataItem: public RsGRouterAbstractMsgItem, public RsGRouterNonCopyableObject @@ -116,15 +106,13 @@ class RsGRouterGenericDataItem: public RsGRouterAbstractMsgItem, public RsGRoute RsGRouterGenericDataItem() : RsGRouterAbstractMsgItem(RS_PKT_SUBTYPE_GROUTER_DATA) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; } virtual ~RsGRouterGenericDataItem() { clear() ; } - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; - virtual void clear() { free(data_bytes); data_bytes=NULL; } - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; + + virtual void serial_process(SerializeJob j,SerializeContext& ctx); RsGRouterGenericDataItem *duplicate() const ; @@ -132,35 +120,23 @@ class RsGRouterGenericDataItem: public RsGRouterAbstractMsgItem, public RsGRoute // uint32_t data_size ; uint8_t *data_bytes; - uint32_t duplication_factor ; // number of duplicates allowed. Should be capped at each de-serialise operation! - - // utility methods for signing data - virtual uint32_t signed_data_size() const ; - virtual bool serialise_signed_data(void *data, uint32_t size) const ; }; class RsGRouterSignedReceiptItem: public RsGRouterAbstractMsgItem { public: RsGRouterSignedReceiptItem() : RsGRouterAbstractMsgItem(RS_PKT_SUBTYPE_GROUTER_SIGNED_RECEIPT) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; } - virtual ~RsGRouterSignedReceiptItem() {} - - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual ~RsGRouterSignedReceiptItem() {} virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; + virtual void serial_process(SerializeJob j,SerializeContext& ctx); RsGRouterSignedReceiptItem *duplicate() const ; // packet data // - Sha1CheckSum data_hash ; // avoids an attacker to re-use a given signed receipt. This is the hash of the enceypted data. - - // utility methods for signing data - virtual uint32_t signed_data_size() const ; - virtual bool serialise_signed_data(void *data, uint32_t size) const ; + Sha1CheckSum data_hash ; // avoids an attacker to re-use a given signed receipt. This is the hash of the enceypted data. }; // Low-level data items @@ -170,62 +146,55 @@ class RsGRouterTransactionItem: public RsGRouterItem public: RsGRouterTransactionItem(uint8_t pkt_subtype) : RsGRouterItem(pkt_subtype) {} - virtual ~RsGRouterTransactionItem() {} + virtual ~RsGRouterTransactionItem() {} - virtual bool serialise(void *data,uint32_t& size) const =0; - virtual uint32_t serial_size() const =0; virtual void clear() =0; - virtual RsGRouterTransactionItem *duplicate() const = 0 ; + virtual RsGRouterTransactionItem *duplicate() const = 0 ; }; class RsGRouterTransactionChunkItem: public RsGRouterTransactionItem, public RsGRouterNonCopyableObject { - public: - RsGRouterTransactionChunkItem() : RsGRouterTransactionItem(RS_PKT_SUBTYPE_GROUTER_TRANSACTION_CHUNK) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; } +public: + RsGRouterTransactionChunkItem() : RsGRouterTransactionItem(RS_PKT_SUBTYPE_GROUTER_TRANSACTION_CHUNK) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; } - virtual ~RsGRouterTransactionChunkItem() { free(chunk_data) ; } + virtual ~RsGRouterTransactionChunkItem() { free(chunk_data) ; } - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void clear() {} + virtual void serial_process(SerializeJob j,SerializeContext& ctx); - virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; + virtual RsGRouterTransactionItem *duplicate() const + { + RsGRouterTransactionChunkItem *item = new RsGRouterTransactionChunkItem ; + *item = *this ; // copy all fields + item->chunk_data = (uint8_t*)rs_malloc(chunk_size) ; // deep copy memory chunk - virtual RsGRouterTransactionItem *duplicate() const - { - RsGRouterTransactionChunkItem *item = new RsGRouterTransactionChunkItem ; - *item = *this ; // copy all fields - item->chunk_data = (uint8_t*)rs_malloc(chunk_size) ; // deep copy memory chunk - - if(item->chunk_data == NULL) - return NULL ; - - memcpy(item->chunk_data,chunk_data,chunk_size) ; - return item ; - } + if(item->chunk_data == NULL) + return NULL ; - GRouterMsgPropagationId propagation_id ; - uint32_t chunk_start ; - uint32_t chunk_size ; - uint32_t total_size ; - uint8_t *chunk_data ; + memcpy(item->chunk_data,chunk_data,chunk_size) ; + return item ; + } + + GRouterMsgPropagationId propagation_id ; + uint32_t chunk_start ; + uint32_t chunk_size ; + uint32_t total_size ; + uint8_t *chunk_data ; }; class RsGRouterTransactionAcknItem: public RsGRouterTransactionItem { - public: - RsGRouterTransactionAcknItem() : RsGRouterTransactionItem(RS_PKT_SUBTYPE_GROUTER_TRANSACTION_ACKN) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; } - virtual ~RsGRouterTransactionAcknItem() {} +public: + RsGRouterTransactionAcknItem() : RsGRouterTransactionItem(RS_PKT_SUBTYPE_GROUTER_TRANSACTION_ACKN) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; } + virtual ~RsGRouterTransactionAcknItem() {} - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(SerializeJob j,SerializeContext& ctx); - virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; + virtual void clear() {} - virtual RsGRouterTransactionItem *duplicate() const { return new RsGRouterTransactionAcknItem(*this) ; } + virtual RsGRouterTransactionItem *duplicate() const { return new RsGRouterTransactionAcknItem(*this) ; } - GRouterMsgPropagationId propagation_id ; + GRouterMsgPropagationId propagation_id ; }; // Items for saving the routing matrix information. @@ -236,11 +205,8 @@ class RsGRouterMatrixCluesItem: public RsGRouterItem RsGRouterMatrixCluesItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_MATRIX_CLUES) { setPriorityLevel(0) ; } // this item is never sent through the network - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; - virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; + virtual void serial_process(SerializeJob j,SerializeContext& ctx); // packet data // @@ -254,17 +220,15 @@ class RsGRouterMatrixTrackItem: public RsGRouterItem RsGRouterMatrixTrackItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_MATRIX_TRACK) { setPriorityLevel(0) ; } // this item is never sent through the network - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(SerializeJob j,SerializeContext& ctx); virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; // packet data // RsGxsMessageId message_id ; - RsPeerId provider_id ; - time_t time_stamp ; + RsPeerId provider_id ; + time_t time_stamp ; }; class RsGRouterMatrixFriendListItem: public RsGRouterItem { @@ -272,11 +236,8 @@ class RsGRouterMatrixFriendListItem: public RsGRouterItem RsGRouterMatrixFriendListItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST) { setPriorityLevel(0) ; } // this item is never sent through the network - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; - - virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; + virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void clear() {} // packet data // @@ -291,8 +252,7 @@ class RsGRouterRoutingInfoItem: public RsGRouterItem, public GRouterRoutingInfo, virtual ~RsGRouterRoutingInfoItem() { clear() ; } - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(SerializeJob j,SerializeContext& ctx); virtual void clear() { @@ -302,47 +262,18 @@ class RsGRouterRoutingInfoItem: public RsGRouterItem, public GRouterRoutingInfo, data_item = NULL ; receipt_item = NULL ; } - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; }; /***********************************************************************************/ /* Serialisation */ /***********************************************************************************/ -class RsGRouterSerialiser: public RsSerialType +class RsGRouterSerialiser: public RsServiceSerializer { public: - RsGRouterSerialiser() : RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GROUTER) {} + RsGRouterSerialiser(SerializationFlags flags = SERIALIZATION_FLAG_NONE) : RsServiceSerializer(RS_SERVICE_TYPE_GROUTER,SerializeContext::FORMAT_BINARY,flags) {} - virtual uint32_t size (RsItem *item) - { - RsGRouterItem *gitem = dynamic_cast(item); - if (!gitem) - { - return 0; - } - return gitem->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - RsGRouterItem *gitem = dynamic_cast(item); - if (!gitem) - { - return false; - } - return gitem->serialise(data,*size) ; - } - virtual RsItem *deserialise (void *data, uint32_t *size) ; - -private: - RsGRouterGenericDataItem *deserialise_RsGRouterGenericDataItem(void *data,uint32_t size) const ; - RsGRouterTransactionChunkItem *deserialise_RsGRouterTransactionChunkItem(void *data,uint32_t size) const ; - RsGRouterTransactionAcknItem *deserialise_RsGRouterTransactionAcknItem(void *data,uint32_t size) const ; - RsGRouterSignedReceiptItem *deserialise_RsGRouterSignedReceiptItem(void *data,uint32_t size) const ; - RsGRouterMatrixCluesItem *deserialise_RsGRouterMatrixCluesItem(void *data,uint32_t size) const ; - RsGRouterMatrixTrackItem *deserialise_RsGRouterMatrixTrackItem(void *data,uint32_t size) const ; - RsGRouterMatrixFriendListItem *deserialise_RsGRouterMatrixFriendListItem(void *data,uint32_t size) const ; - RsGRouterRoutingInfoItem *deserialise_RsGRouterRoutingInfoItem(void *data,uint32_t size) const ; + virtual RsItem *create_item(uint16_t service,uint8_t subtype) const ; }; diff --git a/libretroshare/src/grouter/p3grouter.cc b/libretroshare/src/grouter/p3grouter.cc index f14af4412..998f7e636 100644 --- a/libretroshare/src/grouter/p3grouter.cc +++ b/libretroshare/src/grouter/p3grouter.cc @@ -1263,13 +1263,13 @@ bool p3GRouter::locked_sendTransactionData(const RsPeerId& pid,const RsGRouterTr #ifdef GROUTER_DEBUG std::cerr << " sending to tunnel vpid " << pid << std::endl; #endif - uint32_t turtle_data_size = trans_item.serial_size() ; + uint32_t turtle_data_size = RsGRouterSerialiser().size(const_cast(&trans_item)) ; uint8_t *turtle_data = (uint8_t*)rs_malloc(turtle_data_size) ; if(turtle_data == NULL) return false ; - if(!trans_item.serialise(turtle_data,turtle_data_size)) + if(!RsGRouterSerialiser().serialise(const_cast(&trans_item),turtle_data,&turtle_data_size)) { std::cerr << " ERROR: cannot serialise RsGRouterTransactionChunkItem." << std::endl; @@ -1428,7 +1428,7 @@ bool p3GRouter::sliceDataItem(RsGRouterAbstractMsgItem *item,std::listprint(std::cerr, 2) ; #endif - uint32_t size = item->serial_size(); + uint32_t size = RsGRouterSerialiser().size(item); RsTemporaryMemory data(size) ; // data will be freed on return, whatever the route taken. @@ -1438,7 +1438,7 @@ bool p3GRouter::sliceDataItem(RsGRouterAbstractMsgItem *item,std::listserialise(data,size)) + if(!RsGRouterSerialiser().serialise(item,data,&size)) { std::cerr << " ERROR: cannot serialise." << std::endl; throw ; @@ -1617,12 +1617,15 @@ void p3GRouter::handleIncomingReceiptItem(RsGRouterSignedReceiptItem *receipt_it Sha1CheckSum p3GRouter::computeDataItemHash(RsGRouterGenericDataItem *data_item) { - uint32_t total_size = data_item->signed_data_size() + data_item->signature.TlvSize() ; + RsGRouterSerialiser signature_serializer(RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE | RsGenericSerializer::SERIALIZATION_FLAG_SKIP_HEADER); + + uint32_t signed_data_size = signature_serializer.size(data_item); + uint32_t total_size = signed_data_size + data_item->signature.TlvSize() ; RsTemporaryMemory mem(total_size) ; uint32_t offset = 0 ; - data_item->serialise_signed_data(mem,total_size) ; - offset += data_item->signed_data_size() ; + signature_serializer.serialise(data_item,mem,&total_size) ; + offset += signed_data_size ; data_item->signature.SetTlv(mem, total_size,&offset) ; @@ -1948,28 +1951,45 @@ bool p3GRouter::signDataItem(RsGRouterAbstractMsgItem *item,const RsGxsId& signi { try { -#ifdef GROUTER_DEBUG +//#ifdef GROUTER_DEBUG std::cerr << "p3GRouter::signDataItem()" << std::endl; std::cerr << " Key ID = " << signing_id << std::endl; std::cerr << " Getting key material..." << std::endl; -#endif - uint32_t data_size = item->signed_data_size() ; - RsTemporaryMemory data(data_size) ; +//#endif + RsGRouterSerialiser signature_serializer(RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE | RsGenericSerializer::SERIALIZATION_FLAG_SKIP_HEADER) ; + uint32_t data_size = signature_serializer.size(item) ; + RsTemporaryMemory data(data_size) ; if(data == NULL) throw std::runtime_error("Cannot allocate memory for signing data.") ; - if(!item->serialise_signed_data(data,data_size)) + if(!signature_serializer.serialise(item,data,&data_size)) throw std::runtime_error("Cannot serialise signed data.") ; - uint32_t error_status ; + uint32_t error_status ; - if(!mGixs->signData(data,data_size,signing_id,item->signature,error_status)) - throw std::runtime_error("Cannot sign for id " + signing_id.toStdString() + ". Signature call failed.") ; + std::cerr << "GRouter::signing data" << std::endl; + std::cerr << " size: " << data_size << std::endl; + std::cerr << " data: " << RsUtil::BinToHex(data,data_size) << std::endl; -#ifdef GROUTER_DEBUG + if(!mGixs->signData(data,data_size,signing_id,item->signature,error_status)) + throw std::runtime_error("Cannot sign for id " + signing_id.toStdString() + ". Signature call failed.") ; + +//#ifdef GROUTER_DEBUG std::cerr << "Created signature for data hash: " << RsDirUtil::sha1sum(data,data_size) << " and key id=" << signing_id << std::endl; -#endif +//#endif + // Check signature + RsIdentityUsage::UsageCode info; + uint32_t error; + + if(verifySignedDataItem(item,info,error)) + std::cerr << "Signature checks." << std::endl; + else + { + std::cerr << "(EE) Cannot verify own signed item. Something's wrong." << std::endl; + return false ; + } + return true ; } catch(std::exception& e) @@ -1989,15 +2009,16 @@ bool p3GRouter::verifySignedDataItem(RsGRouterAbstractMsgItem *item,const RsIden std::cerr << "(WW) received global router 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 = item->signed_data_size() ; - RsTemporaryMemory data(data_size) ; + uint32_t data_size = signature_serializer.size(item) ; + RsTemporaryMemory data(data_size) ; - if(data == NULL) - throw std::runtime_error("Cannot allocate data.") ; + if(data == NULL) + throw std::runtime_error("Cannot allocate data.") ; - if(!item->serialise_signed_data(data,data_size)) - throw std::runtime_error("Cannot serialise signed data.") ; + if(!signature_serializer.serialise(item,data,&data_size)) + throw std::runtime_error("Cannot serialise signed data.") ; RsIdentityUsage use(RS_SERVICE_TYPE_GROUTER,info) ; diff --git a/libretroshare/src/pqi/pqistore.cc b/libretroshare/src/pqi/pqistore.cc index ca6d23820..4a962cf29 100644 --- a/libretroshare/src/pqi/pqistore.cc +++ b/libretroshare/src/pqi/pqistore.cc @@ -524,7 +524,7 @@ int pqiSSLstore::readPkt(RsItem **item_out) int extralen = getRsItemSize(block) - blen; int totallen = extralen+blen; - if(totallen > 1024*1024) + if(totallen > 1024*1024 || totallen((const void*)data)) ; RsItem *item = create_item(getRsItemService(rstype),getRsItemSubType(rstype)) ; if(!item) { - std::cerr << "(EE) " << typeid(*this).name() << ": cannot deserialise unknown item subtype " << std::hex << getRsItemSubType(rstype) << std::dec << std::endl; + std::cerr << "(EE) " << typeid(*this).name() << ": cannot deserialise unknown item subtype " << std::hex << (int)getRsItemSubType(rstype) << std::dec << std::endl; std::cerr << "(EE) Data is: " << RsUtil::BinToHex(static_cast(data),std::min(50u,*size)) << ((*size>50)?"...":"") << std::endl; return NULL ; } @@ -40,13 +47,19 @@ RsItem *RsServiceSerializer::deserialise(void *data, uint32_t *size) } RsItem *RsConfigSerializer::deserialise(void *data, uint32_t *size) { + if(mFlags & SERIALIZATION_FLAG_SKIP_HEADER) + { + std::cerr << "(EE) Cannot deserialise item with flags SERIALIZATION_FLAG_SKIP_HEADER. Check your code!" << std::endl; + return NULL ; + } + uint32_t rstype = getRsItemId(const_cast((const void*)data)) ; RsItem *item = create_item(getRsItemType(rstype),getRsItemSubType(rstype)) ; if(!item) { - std::cerr << "(EE) " << typeid(*this).name() << ": cannot deserialise unknown item subtype " << std::hex << getRsItemSubType(rstype) << std::dec << std::endl; + std::cerr << "(EE) " << typeid(*this).name() << ": cannot deserialise unknown item subtype " << std::hex << (int)getRsItemSubType(rstype) << std::dec << std::endl; std::cerr << "(EE) Data is: " << RsUtil::BinToHex(static_cast(data),std::min(50u,*size)) << ((*size>50)?"...":"") << std::endl; return NULL ; } @@ -77,12 +90,19 @@ bool RsGenericSerializer::serialise(RsItem *item,void *data,uint32_t *size) if(tlvsize > *size) throw std::runtime_error("Cannot serialise: not enough room.") ; - if(!setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize)) + + if(mFlags & SERIALIZATION_FLAG_SKIP_HEADER) + ctx.mOffset = 0; + else { - std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; - return false ; + if(!setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize)) + { + std::cerr << "RsSerializer::serialise_item(): ERROR. Not enough size!" << std::endl; + return false ; + } + ctx.mOffset = 8; } - ctx.mOffset = 8; + ctx.mSize = tlvsize; item->serial_process(RsItem::SERIALIZE,ctx) ; @@ -99,7 +119,10 @@ uint32_t RsGenericSerializer::size(RsItem *item) { SerializeContext ctx(NULL,0,mFormat,mFlags); - ctx.mOffset = 8 ; // header size + if(mFlags & SERIALIZATION_FLAG_SKIP_HEADER) + ctx.mOffset = 0; + else + ctx.mOffset = 8 ; // header size item->serial_process(RsItem::SIZE_ESTIMATE, ctx) ; return ctx.mOffset ; diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 3285becf9..700b690f5 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -24,6 +24,7 @@ public: static const SerializationFlags SERIALIZATION_FLAG_NONE ; // 0x0000 static const SerializationFlags SERIALIZATION_FLAG_CONFIG ; // 0x0001 static const SerializationFlags SERIALIZATION_FLAG_SIGNATURE ; // 0x0002 + static const SerializationFlags SERIALIZATION_FLAG_SKIP_HEADER ; // 0x0004 // The following functions overload RsSerialType. They *should not* need to be further overloaded. From 9c610a736da2f1caefcaead5762af23ccdb24e01 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 11:40:46 +0200 Subject: [PATCH 49/94] cleaned the hierarchy of serialization classes --- libretroshare/src/chat/rschatitems.cc | 28 +++--- libretroshare/src/chat/rschatitems.h | 30 +++--- .../src/file_sharing/rsfilelistitems.cc | 6 +- .../src/file_sharing/rsfilelistitems.h | 5 +- .../src/ft/ftturtlefiletransferitem.cc | 12 +-- .../src/ft/ftturtlefiletransferitem.h | 12 +-- libretroshare/src/grouter/grouteritems.cc | 40 ++++---- libretroshare/src/grouter/grouteritems.h | 18 ++-- .../src/gxstunnel/rsgxstunnelitems.h | 5 +- libretroshare/src/libretroshare.pro | 3 +- libretroshare/src/pqi/p3servicecontrol.cc | 1 + libretroshare/src/pqi/pqi.h | 3 +- libretroshare/src/pqi/pqiqos.cc | 4 + libretroshare/src/pqi/pqistore.cc | 1 + libretroshare/src/rsitems/rsbanlistitems.cc | 4 +- libretroshare/src/rsitems/rsbanlistitems.h | 6 +- libretroshare/src/rsitems/rsbwctrlitems.cc | 2 +- libretroshare/src/rsitems/rsbwctrlitems.h | 6 +- libretroshare/src/rsitems/rsconfigitems.cc | 19 ++-- libretroshare/src/rsitems/rsconfigitems.h | 18 ++-- .../src/rsitems/rsdiscovery2items.cc | 8 +- libretroshare/src/rsitems/rsdiscovery2items.h | 8 +- .../src/rsitems/rsfiletransferitems.cc | 12 +-- .../src/rsitems/rsfiletransferitems.h | 14 +-- .../src/rsitems/rsgxsreputationitems.cc | 10 +- .../src/rsitems/rsgxsreputationitems.h | 13 ++- libretroshare/src/rsitems/rshistoryitems.cc | 4 +- libretroshare/src/rsitems/rshistoryitems.h | 2 +- libretroshare/src/rsitems/rsitem.h | 90 ++++++++++++++++++ libretroshare/src/rsitems/rsmsgitems.cc | 18 ++-- libretroshare/src/rsitems/rsmsgitems.h | 18 ++-- libretroshare/src/rsitems/rsrttitems.cc | 6 +- libretroshare/src/rsitems/rsrttitems.h | 6 +- libretroshare/src/serialiser/rsgxsitems.h | 1 + .../src/serialiser/rsgxsrecognitems.h | 3 + .../src/serialiser/rsheartbeatitems.h | 2 + libretroshare/src/serialiser/rsnxsitems.h | 1 + libretroshare/src/serialiser/rsserial.cc | 5 +- libretroshare/src/serialiser/rsserial.h | 94 +------------------ .../src/serialiser/rsserviceinfoitems.h | 3 + .../src/serialiser/rsserviceserialiser.cc | 1 + libretroshare/src/serialiser/rsstatusitems.h | 3 +- .../src/serialization/rsserializer.cc | 12 ++- .../src/serialization/rsserializer.h | 35 +++++-- .../src/serialization/rstypeserializer.h | 84 +++++++---------- libretroshare/src/services/p3service.cc | 2 + libretroshare/src/turtle/rsturtleitem.cc | 12 +-- libretroshare/src/turtle/rsturtleitem.h | 18 ++-- 48 files changed, 382 insertions(+), 326 deletions(-) create mode 100644 libretroshare/src/rsitems/rsitem.h diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 7aa0dd4f3..06bb063a7 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -62,7 +62,7 @@ RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) c } } -void RsChatMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,chatFlags,"chatflags") ; RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; @@ -80,7 +80,7 @@ RsChatAvatarItem::~RsChatAvatarItem() } } -void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, SerializeContext& ctx) +void RsChatLobbyBouncingObject::serial_process(RsGenericSerializer::SerializeJob j, RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; RsTypeSerializer::serial_process(j,ctx,msg_id ,"msg_id") ; @@ -90,19 +90,19 @@ void RsChatLobbyBouncingObject::serial_process(RsItem::SerializeJob j, Serialize RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; } -void RsChatLobbyMsgItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsChatMsgItem::serial_process(j,ctx) ; RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; RsChatLobbyBouncingObject::serial_process(j,ctx) ; } -void RsChatLobbyListRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyListRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { // nothing to do. This is an empty item. } -template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,VisibleChatLobbyInfo& info,const std::string& name) +template<> void RsTypeSerializer::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,VisibleChatLobbyInfo& info,const std::string& name) { RsTypeSerializer::serial_process(j,ctx,info.id,"info.id") ; @@ -112,12 +112,12 @@ template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,Serializ RsTypeSerializer::serial_process (j,ctx, info.flags,"info.flags") ; } -void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,lobbies,"lobbies") ; } -void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyEventItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,event_type,"event_type") ; RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,string1,"string1") ; @@ -125,24 +125,24 @@ void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContex RsChatLobbyBouncingObject::serial_process(j,ctx) ; } -void RsChatLobbyUnsubscribeItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyUnsubscribeItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; } -void RsChatLobbyConnectChallengeItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyConnectChallengeItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,challenge_code,"challenge_code") ; } -void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyInviteItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx, lobby_id, "lobby_id") ; RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,lobby_name, "lobby_name") ; RsTypeSerializer::serial_process (j,ctx, lobby_flags,"lobby_flags") ; } -void RsPrivateChatMsgConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsPrivateChatMsgConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { uint32_t x=0 ; @@ -154,19 +154,19 @@ void RsPrivateChatMsgConfigItem::serial_process(RsItem::SerializeJob j,Serialize RsTypeSerializer::serial_process(j,ctx, recvTime, "recvTime") ; } -void RsChatStatusItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatStatusItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,status_string,"status_string") ; } -void RsChatAvatarItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatAvatarItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::TlvMemBlock_proxy b(image_data,image_size) ; RsTypeSerializer::serial_process(j,ctx,b,"image data") ; } -void RsChatLobbyConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsChatLobbyConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,lobby_Id,"lobby_Id") ; RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 1766dbfec..06de87c7f 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -30,6 +30,8 @@ #include "serialization/rsserializer.h" #include "serialiser/rstlvkeys.h" #include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" +#include "rsitems/rsitem.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" @@ -112,7 +114,7 @@ public: // derived from RsItem - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear() {} uint32_t chatFlags; @@ -142,7 +144,7 @@ protected: // They are called by serial_size() and serialise() from children, but should not overload the serial_size() and // serialise() methods, otherwise the wrong method will be called when serialising from this top level class. - virtual void serial_process(RsItem::SerializeJob j, SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual uint32_t PacketId() const= 0; }; @@ -155,7 +157,7 @@ public: virtual ~RsChatLobbyMsgItem() {} virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyMsgItem(*this) ; } - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx) ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); ChatLobbyMsgId parent_msg_id ; // Used for threaded chat. @@ -171,7 +173,7 @@ public: virtual ~RsChatLobbyEventItem() {} virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyEventItem(*this) ; } // - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // members. // @@ -189,7 +191,7 @@ class RsChatLobbyListRequestItem: public RsChatItem RsChatLobbyListRequestItem() : RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_REQUEST) {} virtual ~RsChatLobbyListRequestItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; struct VisibleChatLobbyInfo @@ -207,7 +209,7 @@ class RsChatLobbyListItem: public RsChatItem RsChatLobbyListItem() : RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_LIST) {} virtual ~RsChatLobbyListItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); std::vector lobbies ; }; @@ -219,7 +221,7 @@ class RsChatLobbyUnsubscribeItem: public RsChatItem virtual ~RsChatLobbyUnsubscribeItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint64_t lobby_id ; }; @@ -231,7 +233,7 @@ class RsChatLobbyConnectChallengeItem: public RsChatItem virtual ~RsChatLobbyConnectChallengeItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint64_t challenge_code ; }; @@ -242,7 +244,7 @@ class RsChatLobbyInviteItem: public RsChatItem RsChatLobbyInviteItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_INVITE) {} virtual ~RsChatLobbyInviteItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); ChatLobbyId lobby_id ; std::string lobby_name ; @@ -262,7 +264,7 @@ class RsPrivateChatMsgConfigItem: public RsChatItem virtual ~RsPrivateChatMsgConfigItem() {} virtual void clear() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); /* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */ void set(RsChatMsgItem *ci, const RsPeerId &peerId, uint32_t confFlags); @@ -286,7 +288,7 @@ public: virtual void clear() { lobby_Id = 0; } - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint64_t lobby_Id; uint32_t flags ; @@ -301,7 +303,7 @@ class RsChatStatusItem: public RsChatItem virtual ~RsChatStatusItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t flags ; std::string status_string; @@ -315,7 +317,7 @@ class RsChatAvatarItem: public RsChatItem RsChatAvatarItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_AVATAR) {setPriorityLevel(QOS_PRIORITY_RS_CHAT_AVATAR_ITEM) ;} virtual ~RsChatAvatarItem() ; - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t image_size ; // size of data in bytes unsigned char *image_data ; // image @@ -325,7 +327,7 @@ class RsChatSerialiser: public RsServiceSerializer { public: RsChatSerialiser(SerializationFlags flags = SERIALIZATION_FLAG_NONE) - :RsServiceSerializer(RS_SERVICE_TYPE_CHAT,SerializeContext::FORMAT_BINARY,flags) {} + :RsServiceSerializer(RS_SERVICE_TYPE_CHAT,RsGenericSerializer::FORMAT_BINARY,flags) {} virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) const ; }; diff --git a/libretroshare/src/file_sharing/rsfilelistitems.cc b/libretroshare/src/file_sharing/rsfilelistitems.cc index 85a94488f..6934f29d2 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.cc +++ b/libretroshare/src/file_sharing/rsfilelistitems.cc @@ -24,16 +24,18 @@ */ #include "serialiser/rsbaseserial.h" +#include "serialization/rstypeserializer.h" + #include "file_sharing/rsfilelistitems.h" -void RsFileListsSyncRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsFileListsSyncRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,entry_hash,"entry_hash") ; RsTypeSerializer::serial_process(j,ctx,flags ,"flags") ; RsTypeSerializer::serial_process(j,ctx,last_known_recurs_modf_TS,"last_known_recurs_modf_TS") ; RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; } -void RsFileListsSyncResponseItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsFileListsSyncResponseItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,entry_hash,"entry_hash") ; RsTypeSerializer::serial_process (j,ctx,checksum,"checksum") ; diff --git a/libretroshare/src/file_sharing/rsfilelistitems.h b/libretroshare/src/file_sharing/rsfilelistitems.h index 391d3dd88..8e45ef251 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.h +++ b/libretroshare/src/file_sharing/rsfilelistitems.h @@ -28,6 +28,7 @@ #include #include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvitem.h" @@ -78,7 +79,7 @@ public: virtual void clear(){} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsFileHash entry_hash ; // hash of the directory to sync uint32_t flags; // used to say that it's a request or a response, say that the directory has been removed, ask for further update, etc. @@ -94,7 +95,7 @@ public: virtual void clear(); - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsFileHash entry_hash ; // hash of the directory to sync RsFileHash checksum ; // checksum of the bindary data, for checking diff --git a/libretroshare/src/ft/ftturtlefiletransferitem.cc b/libretroshare/src/ft/ftturtlefiletransferitem.cc index 5c343b7fa..3009fb87c 100644 --- a/libretroshare/src/ft/ftturtlefiletransferitem.cc +++ b/libretroshare/src/ft/ftturtlefiletransferitem.cc @@ -32,37 +32,37 @@ #include -void RsTurtleFileMapRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleFileMapRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,direction,"direction") ; } -void RsTurtleFileMapItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleFileMapItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,direction,"direction") ; RsTypeSerializer::serial_process (j,ctx,compressed_map._map,"map") ; } -void RsTurtleChunkCrcRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleChunkCrcRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,chunk_number,"chunk_number") ; } -void RsTurtleChunkCrcItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleChunkCrcItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,chunk_number,"chunk_number") ; RsTypeSerializer::serial_process (j,ctx,check_sum,"check_sum") ; } -void RsTurtleFileRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleFileRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,chunk_offset,"chunk_offset") ; RsTypeSerializer::serial_process(j,ctx,chunk_size,"chunk_size") ; } -void RsTurtleFileDataItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleFileDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,chunk_offset,"chunk_offset") ; diff --git a/libretroshare/src/ft/ftturtlefiletransferitem.h b/libretroshare/src/ft/ftturtlefiletransferitem.h index fd8aada93..ce4a25217 100644 --- a/libretroshare/src/ft/ftturtlefiletransferitem.h +++ b/libretroshare/src/ft/ftturtlefiletransferitem.h @@ -43,7 +43,7 @@ class RsTurtleFileRequestItem: public RsTurtleGenericTunnelItem void clear() {} protected: - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; class RsTurtleFileDataItem: public RsTurtleGenericTunnelItem @@ -67,7 +67,7 @@ class RsTurtleFileDataItem: public RsTurtleGenericTunnelItem uint32_t chunk_size ; // size of the file chunk void *chunk_data ; // actual data. - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; class RsTurtleFileMapRequestItem: public RsTurtleGenericTunnelItem @@ -78,7 +78,7 @@ class RsTurtleFileMapRequestItem: public RsTurtleGenericTunnelItem virtual bool shouldStampTunnel() const { return false ; } void clear() {} - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; class RsTurtleFileMapItem: public RsTurtleGenericTunnelItem @@ -93,7 +93,7 @@ class RsTurtleFileMapItem: public RsTurtleGenericTunnelItem // with the default file map for this source. void clear() { compressed_map._map.clear() ;} - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; class RsTurtleChunkCrcRequestItem: public RsTurtleGenericTunnelItem @@ -107,7 +107,7 @@ class RsTurtleChunkCrcRequestItem: public RsTurtleGenericTunnelItem uint32_t chunk_number ; // id of the chunk to CRC. void clear() {} - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; class RsTurtleChunkCrcItem: public RsTurtleGenericTunnelItem @@ -122,5 +122,5 @@ class RsTurtleChunkCrcItem: public RsTurtleGenericTunnelItem Sha1CheckSum check_sum ; void clear() { check_sum.clear() ;} - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; diff --git a/libretroshare/src/grouter/grouteritems.cc b/libretroshare/src/grouter/grouteritems.cc index c48dbc134..48da81548 100644 --- a/libretroshare/src/grouter/grouteritems.cc +++ b/libretroshare/src/grouter/grouteritems.cc @@ -3,6 +3,8 @@ #include "serialiser/rstlvbase.h" #include "grouteritems.h" +#include "serialization/rstypeserializer.h" + /**********************************************************************************************/ /* SERIALISER STUFF */ /**********************************************************************************************/ @@ -28,7 +30,7 @@ RsItem *RsGRouterSerialiser::create_item(uint16_t service_id,uint8_t subtype) co } } -void RsGRouterTransactionChunkItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsGRouterTransactionChunkItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,propagation_id,"propagation_id") ; RsTypeSerializer::serial_process(j,ctx,chunk_start ,"chunk_start") ; @@ -37,7 +39,7 @@ void RsGRouterTransactionChunkItem::serial_process(SerializeJob j,SerializeConte // Hack for backward compatibility (the chunk size is not directly next to the chunk data) - if(j == RsItem::DESERIALIZE) + if(j == RsGenericSerializer::DESERIALIZE) { if(chunk_size > ctx.mSize || ctx.mOffset > ctx.mSize - chunk_size) // better than if(chunk_size + offset > size) { @@ -54,12 +56,12 @@ void RsGRouterTransactionChunkItem::serial_process(SerializeJob j,SerializeConte memcpy(chunk_data,&((uint8_t*)ctx.mData)[ctx.mOffset],chunk_size) ; ctx.mOffset += chunk_size ; } - else if(j== RsItem::SERIALIZE) + else if(j== RsGenericSerializer::SERIALIZE) { memcpy(&((uint8_t*)ctx.mData)[ctx.mOffset],chunk_data,chunk_size) ; ctx.mOffset += chunk_size ; } - else if(j== RsItem::SIZE_ESTIMATE) + else if(j== RsGenericSerializer::SIZE_ESTIMATE) ctx.mOffset += chunk_size ; else std::cerr << " [Binary data] " << ", length=" << chunk_size << " data=" << RsUtil::BinToHex((uint8_t*)chunk_data,std::min(50u,chunk_size)) << ((chunk_size>50)?"...":"") << std::endl; @@ -112,7 +114,7 @@ RsGRouterTransactionChunkItem *RsGRouterSerialiser::deserialise_RsGRouterTransac } #endif -void RsGRouterTransactionAcknItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsGRouterTransactionAcknItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,propagation_id,"propagation_id") ; } @@ -140,7 +142,7 @@ RsGRouterTransactionAcknItem *RsGRouterSerialiser::deserialise_RsGRouterTransact } #endif -void RsGRouterGenericDataItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsGRouterGenericDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,routing_id,"routing_id") ; RsTypeSerializer::serial_process (j,ctx,destination_key,"destination_key") ; @@ -157,7 +159,7 @@ void RsGRouterGenericDataItem::serial_process(SerializeJob j,SerializeContext& c RsTypeSerializer::serial_process(j,ctx,duplication_factor,"duplication_factor") ; RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; - if(j == RsItem::DESERIALIZE) // make sure the duplication factor is not altered by friends. In the worst case, the item will duplicate a bit more. + 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. { if(duplication_factor < 1) { @@ -242,7 +244,7 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI } #endif -void RsGRouterSignedReceiptItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsGRouterSignedReceiptItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,routing_id,"routing_id") ; RsTypeSerializer::serial_process (j,ctx,flags,"flags") ; @@ -283,7 +285,7 @@ RsGRouterSignedReceiptItem *RsGRouterSerialiser::deserialise_RsGRouterSignedRece } #endif -void RsGRouterRoutingInfoItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsGRouterRoutingInfoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,peerId,"peerId") ; RsTypeSerializer::serial_process(j,ctx,data_status,"data_status") ; @@ -304,7 +306,7 @@ void RsGRouterRoutingInfoItem::serial_process(SerializeJob j,SerializeContext& c // Hack for backward compatibility. Normally we should need a single commandline to serialise/deserialise a single item here. // But the full item is serialised, so we need the header. - if(j == RsItem::DESERIALIZE) + if(j == RsGenericSerializer::DESERIALIZE) { data_item = new RsGRouterGenericDataItem() ; @@ -321,7 +323,7 @@ void RsGRouterRoutingInfoItem::serial_process(SerializeJob j,SerializeContext& c else receipt_item = NULL ; } - else if(j == RsItem::SERIALIZE) + else if(j == RsGenericSerializer::SERIALIZE) { uint32_t remaining_size = ctx.mSize - ctx.mOffset; ctx.mOk = ctx.mOk && RsGRouterSerialiser().serialise(data_item,ctx.mData,&remaining_size) ; @@ -330,18 +332,18 @@ void RsGRouterRoutingInfoItem::serial_process(SerializeJob j,SerializeContext& c if(receipt_item != NULL) { remaining_size = ctx.mSize - ctx.mOffset; - ctx.mOk = ctx.mOk && RsGRouterSerialiser().serialise(data_item,ctx.mData,&remaining_size); - ctx.mOffset += RsGRouterSerialiser().size(data_item) ; + ctx.mOk = ctx.mOk && RsGRouterSerialiser().serialise(receipt_item,ctx.mData,&remaining_size); + ctx.mOffset += RsGRouterSerialiser().size(receipt_item) ; } } - else if(j == RsItem::PRINT) + else if(j == RsGenericSerializer::PRINT) { std::cerr << " [Serialized data] " << std::endl; if(receipt_item != NULL) std::cerr << " [Receipt item ]" << std::endl; } - else if(j == RsItem::SIZE_ESTIMATE) + else if(j == RsGenericSerializer::SIZE_ESTIMATE) { ctx.mOffset += RsGRouterSerialiser().size(data_item) ; @@ -410,7 +412,7 @@ RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoI } #endif -void RsGRouterMatrixFriendListItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsGRouterMatrixFriendListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,reverse_friend_indices,"reverse_friend_indices") ; } @@ -443,7 +445,7 @@ RsGRouterMatrixFriendListItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixF } #endif -void RsGRouterMatrixTrackItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsGRouterMatrixTrackItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,provider_id,"provider_id") ; RsTypeSerializer::serial_process(j,ctx,message_id,"message_id") ; @@ -474,13 +476,13 @@ RsGRouterMatrixTrackItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixTrackI } #endif -void RsGRouterMatrixCluesItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsGRouterMatrixCluesItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,destination_key,"destination_key") ; RsTypeSerializer::serial_process(j,ctx,clues,"clues") ; } -template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,SerializeContext& ctx,RoutingMatrixHitEntry& s,const std::string& name) +template<> void RsTypeSerializer::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,RoutingMatrixHitEntry& s,const std::string& name) { RsTypeSerializer::serial_process(j,ctx,s.friend_id,name+":friend_id") ; RsTypeSerializer::serial_process (j,ctx,s.weight,name+":weight") ; diff --git a/libretroshare/src/grouter/grouteritems.h b/libretroshare/src/grouter/grouteritems.h index 7c69d4718..505f35361 100644 --- a/libretroshare/src/grouter/grouteritems.h +++ b/libretroshare/src/grouter/grouteritems.h @@ -112,7 +112,7 @@ class RsGRouterGenericDataItem: public RsGRouterAbstractMsgItem, public RsGRoute data_bytes=NULL; } - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsGRouterGenericDataItem *duplicate() const ; @@ -130,7 +130,7 @@ class RsGRouterSignedReceiptItem: public RsGRouterAbstractMsgItem virtual ~RsGRouterSignedReceiptItem() {} virtual void clear() {} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsGRouterSignedReceiptItem *duplicate() const ; @@ -161,7 +161,7 @@ public: virtual ~RsGRouterTransactionChunkItem() { free(chunk_data) ; } virtual void clear() {} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual RsGRouterTransactionItem *duplicate() const { @@ -188,7 +188,7 @@ public: RsGRouterTransactionAcknItem() : RsGRouterTransactionItem(RS_PKT_SUBTYPE_GROUTER_TRANSACTION_ACKN) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; } virtual ~RsGRouterTransactionAcknItem() {} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear() {} @@ -206,7 +206,7 @@ class RsGRouterMatrixCluesItem: public RsGRouterItem { setPriorityLevel(0) ; } // this item is never sent through the network virtual void clear() {} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // packet data // @@ -220,7 +220,7 @@ class RsGRouterMatrixTrackItem: public RsGRouterItem RsGRouterMatrixTrackItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_MATRIX_TRACK) { setPriorityLevel(0) ; } // this item is never sent through the network - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear() {} @@ -236,7 +236,7 @@ class RsGRouterMatrixFriendListItem: public RsGRouterItem RsGRouterMatrixFriendListItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST) { setPriorityLevel(0) ; } // this item is never sent through the network - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear() {} // packet data @@ -252,7 +252,7 @@ class RsGRouterRoutingInfoItem: public RsGRouterItem, public GRouterRoutingInfo, virtual ~RsGRouterRoutingInfoItem() { clear() ; } - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear() { @@ -271,7 +271,7 @@ class RsGRouterRoutingInfoItem: public RsGRouterItem, public GRouterRoutingInfo, class RsGRouterSerialiser: public RsServiceSerializer { public: - RsGRouterSerialiser(SerializationFlags flags = SERIALIZATION_FLAG_NONE) : RsServiceSerializer(RS_SERVICE_TYPE_GROUTER,SerializeContext::FORMAT_BINARY,flags) {} + RsGRouterSerialiser(SerializationFlags flags = SERIALIZATION_FLAG_NONE) : RsServiceSerializer(RS_SERVICE_TYPE_GROUTER,RsGenericSerializer::FORMAT_BINARY,flags) {} virtual RsItem *create_item(uint16_t service,uint8_t subtype) const ; }; diff --git a/libretroshare/src/gxstunnel/rsgxstunnelitems.h b/libretroshare/src/gxstunnel/rsgxstunnelitems.h index ad049a753..4da26da0e 100644 --- a/libretroshare/src/gxstunnel/rsgxstunnelitems.h +++ b/libretroshare/src/gxstunnel/rsgxstunnelitems.h @@ -27,9 +27,12 @@ #include +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" +#include "rsitems/rsitem.h" + #include "retroshare/rstypes.h" #include "serialiser/rstlvkeys.h" -#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 8a633c1a7..287e6a4d7 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -452,7 +452,8 @@ HEADERS += grouter/groutercache.h \ grouter/groutertypes.h \ grouter/rsgrouterclient.h -HEADERS += rsitems/itempriorities.h \ +HEADERS += rsitems/rsitem.h \ + rsitems/itempriorities.h \ serialiser/rsbaseserial.h \ rsitems/rsfiletransferitems.h \ serialiser/rsserviceserialiser.h \ diff --git a/libretroshare/src/pqi/p3servicecontrol.cc b/libretroshare/src/pqi/p3servicecontrol.cc index f22cc44c0..0b3b1514e 100644 --- a/libretroshare/src/pqi/p3servicecontrol.cc +++ b/libretroshare/src/pqi/p3servicecontrol.cc @@ -27,6 +27,7 @@ #include "p3servicecontrol.h" #include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" #include "serialiser/rsserial.h" #include "serialiser/rsbaseserial.h" #include "pqi/p3cfgmgr.h" diff --git a/libretroshare/src/pqi/pqi.h b/libretroshare/src/pqi/pqi.h index a7aa5854c..07cf00f9d 100644 --- a/libretroshare/src/pqi/pqi.h +++ b/libretroshare/src/pqi/pqi.h @@ -27,8 +27,7 @@ #ifndef PQI_TOP_HEADER #define PQI_TOP_HEADER -#include "serialiser/rsserial.h" - +#include "rsitems/rsitem.h" class P3Interface { diff --git a/libretroshare/src/pqi/pqiqos.cc b/libretroshare/src/pqi/pqiqos.cc index b2472c0b7..9fc62aa8c 100644 --- a/libretroshare/src/pqi/pqiqos.cc +++ b/libretroshare/src/pqi/pqiqos.cc @@ -11,7 +11,9 @@ const uint32_t pqiQoS::MAX_PACKET_COUNTER_VALUE = (1 << 24) ; pqiQoS::pqiQoS(uint32_t nb_levels,float alpha) : _item_queues(nb_levels),_alpha(alpha) { +#ifdef DEBUG assert(pow(alpha,nb_levels) < 1e+20) ; +#endif float c = 1.0f ; float inc = alpha ; @@ -110,7 +112,9 @@ void *pqiQoS::out_rsItem(uint32_t max_slice_size, uint32_t& size, bool& starts, if(last >= 0) { +#ifdef DEBUG assert(_nb_items > 0) ; +#endif // now chop a slice of this item diff --git a/libretroshare/src/pqi/pqistore.cc b/libretroshare/src/pqi/pqistore.cc index 4a962cf29..23201541a 100644 --- a/libretroshare/src/pqi/pqistore.cc +++ b/libretroshare/src/pqi/pqistore.cc @@ -40,6 +40,7 @@ * */ +#include "rsitems/rsitem.h" #include "pqi/pqistore.h" #include "serialiser/rsserial.h" #include diff --git a/libretroshare/src/rsitems/rsbanlistitems.cc b/libretroshare/src/rsitems/rsbanlistitems.cc index d597abcfd..85acfb96c 100644 --- a/libretroshare/src/rsitems/rsbanlistitems.cc +++ b/libretroshare/src/rsitems/rsbanlistitems.cc @@ -41,12 +41,12 @@ void RsBanListItem::clear() peerList.TlvClear(); } -void RsBanListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsBanListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,peerList,"peerList") ; } -void RsBanListConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsBanListConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,type,"type") ; RsTypeSerializer::serial_process (j,ctx,peerId,"peerId") ; diff --git a/libretroshare/src/rsitems/rsbanlistitems.h b/libretroshare/src/rsitems/rsbanlistitems.h index 3fce37956..836fe1b7e 100644 --- a/libretroshare/src/rsitems/rsbanlistitems.h +++ b/libretroshare/src/rsitems/rsbanlistitems.h @@ -29,6 +29,8 @@ #include #include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" #include "serialiser/rstlvbanlist.h" #include "serialization/rsserializer.h" @@ -50,7 +52,7 @@ class RsBanListItem: public RsItem virtual ~RsBanListItem(){} virtual void clear(); - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsTlvBanList peerList; }; @@ -64,7 +66,7 @@ public: virtual ~RsBanListConfigItem(){} virtual void clear() { banned_peers.TlvClear() ; } - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t type ; RsPeerId peerId ; diff --git a/libretroshare/src/rsitems/rsbwctrlitems.cc b/libretroshare/src/rsitems/rsbwctrlitems.cc index 747dbbbda..45c23d2c8 100644 --- a/libretroshare/src/rsitems/rsbwctrlitems.cc +++ b/libretroshare/src/rsitems/rsbwctrlitems.cc @@ -52,7 +52,7 @@ void RsBwCtrlAllowedItem::clear() allowedBw = 0; } -void RsBwCtrlAllowedItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsBwCtrlAllowedItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_UINT32_BW,allowedBw,"allowedBw") ; } diff --git a/libretroshare/src/rsitems/rsbwctrlitems.h b/libretroshare/src/rsitems/rsbwctrlitems.h index e21410b39..570e0d87b 100644 --- a/libretroshare/src/rsitems/rsbwctrlitems.h +++ b/libretroshare/src/rsitems/rsbwctrlitems.h @@ -28,9 +28,9 @@ #include +#include "rsitems/rsitem.h" #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" -#include "serialiser/rstlvbase.h" +#include "rsitems/itempriorities.h" #include "serialization/rsserializer.h" #include "serialization/rstypeserializer.h" @@ -51,7 +51,7 @@ public: virtual ~RsBwCtrlAllowedItem() {} virtual void clear(); - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t allowedBw; // Units are bytes/sec => 4Gb/s; }; diff --git a/libretroshare/src/rsitems/rsconfigitems.cc b/libretroshare/src/rsitems/rsconfigitems.cc index 4ba94a8bf..743e35871 100644 --- a/libretroshare/src/rsitems/rsconfigitems.cc +++ b/libretroshare/src/rsitems/rsconfigitems.cc @@ -28,6 +28,7 @@ #include "rsitems/rsconfigitems.h" #include "retroshare/rspeers.h" // Needed for RsGroupInfo. +#include "serialization/rstypeserializer.h" /*** * #define RSSERIAL_DEBUG 1 * #define RSSERIAL_ERROR_DEBUG 1 @@ -69,7 +70,7 @@ void RsFileTransfer::clear() } -void RsFileTransfer::serial_process(SerializeJob j,SerializeContext& ctx) +void RsFileTransfer::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,file,"file") ; RsTypeSerializer::serial_process(j,ctx,allPeerIds,"allPeerIds") ; @@ -91,7 +92,7 @@ void RsFileTransfer::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process (j,ctx,compressed_chunk_map,"compressed_chunk_map") ; } -void RsFileConfigItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsFileConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,file,"file") ; RsTypeSerializer::serial_process (j,ctx,flags,"flags") ; @@ -111,7 +112,7 @@ RsItem *RsGeneralConfigSerialiser::create_item(uint8_t item_type,uint8_t item_su } } -void RsConfigKeyValueSet::serial_process(SerializeJob j,SerializeContext& ctx) +void RsConfigKeyValueSet::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tlvkvs,"tlvkvs") ; } @@ -156,7 +157,7 @@ void RsPeerNetItem::clear() domain_addr.clear(); domain_port = 0; } -void RsPeerNetItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsPeerNetItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,peerId,"peerId") ; RsTypeSerializer::serial_process(j,ctx,pgpId,"pgpId") ; @@ -181,12 +182,12 @@ void RsPeerNetItem::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process(j,ctx,domain_port,"domain_port") ; } -void RsPeerBandwidthLimitsItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsPeerBandwidthLimitsItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,peers,"peers") ; } -void RsPeerStunItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsPeerStunItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,stunList,"stunList") ; } @@ -226,7 +227,7 @@ RsNodeGroupItem::RsNodeGroupItem(const RsGroupInfo& g) pgpList.ids = g.peerIds; } -void RsNodeGroupItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsNodeGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { uint32_t v=0 ; @@ -237,14 +238,14 @@ void RsNodeGroupItem::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process(j,ctx,pgpList,"pgpList") ; } -void RsPeerServicePermissionItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsPeerServicePermissionItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { // We need to hack this because of backward compatibility. The correct way to do it would be: // // RsTypeSerializer::serial_process(j,ctx,pgp_ids,"pgp_ids") ; // RsTypeSerializer::serial_process(j,ctx,service_flags,"service_flags") ; - if(j == RsItem::DESERIALIZE) + if(j == RsGenericSerializer::DESERIALIZE) { uint32_t v=0 ; RsTypeSerializer::serial_process(j,ctx,v,"pgp_ids.size()") ; diff --git a/libretroshare/src/rsitems/rsconfigitems.h b/libretroshare/src/rsitems/rsconfigitems.h index 6ac90c212..bc4b9e824 100644 --- a/libretroshare/src/rsitems/rsconfigitems.h +++ b/libretroshare/src/rsitems/rsconfigitems.h @@ -29,6 +29,8 @@ #include #include +#include "rsitems/rsitem.h" + #include "retroshare/rstypes.h" #include "serialiser/rsserial.h" @@ -77,7 +79,7 @@ public: virtual ~RsPeerNetItem(){} virtual void clear(); - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); /* networking information */ RsPeerId peerId; /* Mandatory */ @@ -115,7 +117,7 @@ class RsPeerServicePermissionItem : public RsItem pgp_ids.clear() ; service_flags.clear() ; } - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); /* Mandatory */ @@ -132,7 +134,7 @@ class RsPeerBandwidthLimitsItem : public RsItem { peers.clear() ; } - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); /* Mandatory */ std::map peers ; @@ -172,7 +174,7 @@ public: explicit RsNodeGroupItem(const RsGroupInfo&) ; - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // /* set data from RsGroupInfo to RsPeerGroupItem */ // void set(RsGroupInfo &groupInfo); @@ -197,7 +199,7 @@ public: virtual ~RsPeerStunItem(){} virtual void clear() { stunList.TlvClear() ;} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsTlvPeerIdSet stunList; /* Mandatory */ }; @@ -277,7 +279,7 @@ class RsFileTransfer: public RsItem virtual ~RsFileTransfer(){} virtual void clear(); - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsTlvFileItem file; RsTlvPeerIdSet allPeerIds; @@ -331,7 +333,7 @@ public: virtual ~RsFileConfigItem() {} virtual void clear() { parent_groups.TlvClear(); } - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsTlvFileItem file; uint32_t flags; @@ -359,7 +361,7 @@ public: virtual ~RsConfigKeyValueSet(){} virtual void clear() { tlvkvs.TlvClear();} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsTlvKeyValueSet tlvkvs; }; diff --git a/libretroshare/src/rsitems/rsdiscovery2items.cc b/libretroshare/src/rsitems/rsdiscovery2items.cc index 8e4175a9e..f9f19270c 100644 --- a/libretroshare/src/rsitems/rsdiscovery2items.cc +++ b/libretroshare/src/rsitems/rsdiscovery2items.cc @@ -73,7 +73,7 @@ void RsDiscPgpListItem::clear() pgpIdSet.TlvClear(); } -void RsDiscPgpListItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsDiscPgpListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,mode,"mode") ; RsTypeSerializer::serial_process(j,ctx,pgpIdSet,"pgpIdSet") ; @@ -86,7 +86,7 @@ void RsDiscPgpCertItem::clear() } -void RsDiscPgpCertItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsDiscPgpCertItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,pgpId,"pgpId") ; RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_PGPCERT,pgpCert,"pgpCert") ; @@ -121,7 +121,7 @@ void RsDiscContactItem::clear() extAddrList.TlvClear(); } -void RsDiscContactItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsDiscContactItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,pgpId,"pgpId"); RsTypeSerializer::serial_process (j,ctx,sslId,"sslId"); @@ -134,7 +134,7 @@ void RsDiscContactItem::serial_process(SerializeJob j,SerializeContext& ctx) // This is a hack. Normally we should have to different item types, in order to avoid this nonesense. - if(j == RsItem::DESERIALIZE) + if(j == RsGenericSerializer::DESERIALIZE) isHidden = ( GetTlvType( &(((uint8_t *) ctx.mData)[ctx.mOffset]) )==TLV_TYPE_STR_DOMADDR); if(isHidden) diff --git a/libretroshare/src/rsitems/rsdiscovery2items.h b/libretroshare/src/rsitems/rsdiscovery2items.h index 7610d534f..ce30a2928 100644 --- a/libretroshare/src/rsitems/rsdiscovery2items.h +++ b/libretroshare/src/rsitems/rsdiscovery2items.h @@ -32,6 +32,8 @@ #include "serialiser/rstlvidset.h" #include "serialiser/rstlvaddrs.h" #include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" #include "serialization/rsserializer.h" @@ -65,7 +67,7 @@ public: virtual ~RsDiscPgpListItem(){} virtual void clear(); - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); uint32_t mode; RsTlvPgpIdSet pgpIdSet; @@ -86,7 +88,7 @@ public: virtual ~RsDiscPgpCertItem(){} virtual void clear(); - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); RsPgpId pgpId; std::string pgpCert; @@ -106,7 +108,7 @@ public: virtual ~RsDiscContactItem() {} virtual void clear(); - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); RsPgpId pgpId; RsPeerId sslId; diff --git a/libretroshare/src/rsitems/rsfiletransferitems.cc b/libretroshare/src/rsitems/rsfiletransferitems.cc index acdadaff2..cd0ea088d 100644 --- a/libretroshare/src/rsitems/rsfiletransferitems.cc +++ b/libretroshare/src/rsitems/rsfiletransferitems.cc @@ -53,38 +53,38 @@ void RsFileTransferDataItem::clear() fd.TlvClear(); } -void RsFileTransferDataRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsFileTransferDataRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,fileoffset,"fileoffset") ; RsTypeSerializer::serial_process (j,ctx,chunksize, "chunksize") ; RsTypeSerializer::serial_process(j,ctx,file, "file") ; } -void RsFileTransferDataItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsFileTransferDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,fd,"fd") ; } -void RsFileTransferChunkMapRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsFileTransferChunkMapRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,is_client,"is_client") ; RsTypeSerializer::serial_process (j,ctx,hash, "hash") ; } -void RsFileTransferChunkMapItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsFileTransferChunkMapItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,is_client, "is_client") ; RsTypeSerializer::serial_process (j,ctx,hash, "hash") ; RsTypeSerializer::serial_process (j,ctx,compressed_map,"compressed_map") ; } -void RsFileTransferSingleChunkCrcRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsFileTransferSingleChunkCrcRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,hash, "hash") ; RsTypeSerializer::serial_process(j,ctx,chunk_number,"chunk_number") ; } -void RsFileTransferSingleChunkCrcItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsFileTransferSingleChunkCrcItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,hash, "hash") ; RsTypeSerializer::serial_process(j,ctx,chunk_number,"chunk_number") ; diff --git a/libretroshare/src/rsitems/rsfiletransferitems.h b/libretroshare/src/rsitems/rsfiletransferitems.h index b51e74d53..b0ab0972a 100644 --- a/libretroshare/src/rsitems/rsfiletransferitems.h +++ b/libretroshare/src/rsitems/rsfiletransferitems.h @@ -30,7 +30,9 @@ #include "retroshare/rstypes.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvfileitem.h" +#include "rsitems/rsitem.h" #include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" #include "serialization/rsserializer.h" @@ -70,7 +72,7 @@ class RsFileTransferDataRequestItem: public RsFileTransferItem virtual ~RsFileTransferDataRequestItem() {} virtual void clear(); - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // Private data part. // @@ -90,7 +92,7 @@ class RsFileTransferDataItem: public RsFileTransferItem } virtual ~RsFileTransferDataItem() { clear() ; } - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear(); @@ -109,7 +111,7 @@ class RsFileTransferChunkMapRequestItem: public RsFileTransferItem virtual ~RsFileTransferChunkMapRequestItem() {} virtual void clear() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // Private data part. // @@ -127,7 +129,7 @@ class RsFileTransferChunkMapItem: public RsFileTransferItem } virtual ~RsFileTransferChunkMapItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear() {} // Private data part. @@ -146,7 +148,7 @@ class RsFileTransferSingleChunkCrcRequestItem: public RsFileTransferItem } virtual ~RsFileTransferSingleChunkCrcRequestItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear() {} // Private data part. @@ -164,7 +166,7 @@ class RsFileTransferSingleChunkCrcItem: public RsFileTransferItem } virtual ~RsFileTransferSingleChunkCrcItem() {} - void serial_process(RsItem::SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear() {} // Private data part. diff --git a/libretroshare/src/rsitems/rsgxsreputationitems.cc b/libretroshare/src/rsitems/rsgxsreputationitems.cc index 11e267654..1a50bf9dc 100644 --- a/libretroshare/src/rsitems/rsgxsreputationitems.cc +++ b/libretroshare/src/rsitems/rsgxsreputationitems.cc @@ -53,21 +53,21 @@ void RsGxsReputationBannedNodeSetItem::clear() mKnownIdentities.TlvClear(); } -void RsGxsReputationConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsGxsReputationConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,mPeerId,"mPeerId") ; RsTypeSerializer::serial_process(j,ctx,mLatestUpdate,"mLatestUpdate") ; RsTypeSerializer::serial_process(j,ctx,mLastQuery,"mLastQuery") ; } -void RsGxsReputationBannedNodeSetItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsGxsReputationBannedNodeSetItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,mPgpId,"mPgpId") ; RsTypeSerializer::serial_process (j,ctx,mLastActivityTS,"mLastActivityTS") ; RsTypeSerializer::serial_process(j,ctx,mKnownIdentities,"mKnownIdentities") ; } -void RsGxsReputationSetItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsGxsReputationSetItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,mGxsId,"mGxsId") ; RsTypeSerializer::serial_process(j,ctx,mOwnOpinion,"mOwnOpinion") ; @@ -78,12 +78,12 @@ void RsGxsReputationSetItem::serial_process(RsItem::SerializeJob j,SerializeCont RsTypeSerializer::serial_process (j,ctx,mOpinions,"mOpinions") ; } -void RsGxsReputationUpdateItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsGxsReputationUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,mLatestUpdate,"mLatestUpdate") ; RsTypeSerializer::serial_process (j,ctx,mOpinions,"mOpinions") ; } -void RsGxsReputationRequestItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx) +void RsGxsReputationRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,mLastUpdate,"mLastUpdate") ; } diff --git a/libretroshare/src/rsitems/rsgxsreputationitems.h b/libretroshare/src/rsitems/rsgxsreputationitems.h index 1f30a5d65..7c841bd4e 100644 --- a/libretroshare/src/rsitems/rsgxsreputationitems.h +++ b/libretroshare/src/rsitems/rsgxsreputationitems.h @@ -29,6 +29,9 @@ #include #include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" + #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" #include "retroshare/rsgxsifacetypes.h" @@ -66,7 +69,7 @@ public: virtual ~RsGxsReputationConfigItem() {} virtual void clear() {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; RsPeerId mPeerId; uint32_t mLatestUpdate; // timestamp they returned. @@ -110,7 +113,7 @@ public: virtual ~RsGxsReputationSetItem() {} virtual void clear(); - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; RsGxsId mGxsId; uint32_t mOwnOpinion; @@ -128,7 +131,7 @@ public: virtual ~RsGxsReputationBannedNodeSetItem() {} virtual void clear(); - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; RsPgpId mPgpId ; uint32_t mLastActivityTS ; @@ -143,7 +146,7 @@ public: virtual ~RsGxsReputationUpdateItem() {} virtual void clear(); - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; uint32_t mLatestUpdate; std::map mOpinions; // GxsId -> Opinion. @@ -157,7 +160,7 @@ public: virtual ~RsGxsReputationRequestItem() {} virtual void clear() {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) ; + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; uint32_t mLastUpdate; }; diff --git a/libretroshare/src/rsitems/rshistoryitems.cc b/libretroshare/src/rsitems/rshistoryitems.cc index eb50bf15e..38f2f0254 100644 --- a/libretroshare/src/rsitems/rshistoryitems.cc +++ b/libretroshare/src/rsitems/rshistoryitems.cc @@ -29,13 +29,15 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" +#include "serialization/rstypeserializer.h" + /*** #define RSSERIAL_DEBUG 1 ***/ #include -void RsHistoryMsgItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsHistoryMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { uint16_t version=0; diff --git a/libretroshare/src/rsitems/rshistoryitems.h b/libretroshare/src/rsitems/rshistoryitems.h index 27a387f60..56d12e559 100644 --- a/libretroshare/src/rsitems/rshistoryitems.h +++ b/libretroshare/src/rsitems/rshistoryitems.h @@ -42,7 +42,7 @@ public: virtual ~RsHistoryMsgItem() {} virtual void clear() {} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsPeerId chatPeerId; // empty for global chat bool incoming; diff --git a/libretroshare/src/rsitems/rsitem.h b/libretroshare/src/rsitems/rsitem.h new file mode 100644 index 000000000..f7f6dae54 --- /dev/null +++ b/libretroshare/src/rsitems/rsitem.h @@ -0,0 +1,90 @@ +#pragma once + +#include "util/smallobject.h" +#include "retroshare/rstypes.h" +#include "serialization/rsserializer.h" + +class RsItem: public RsMemoryManagement::SmallObject +{ + public: + RsItem(uint32_t t); + RsItem(uint8_t ver, uint8_t cls, uint8_t t, uint8_t subtype); +#ifdef DO_STATISTICS + void *operator new(size_t s) ; + void operator delete(void *,size_t s) ; +#endif + + virtual ~RsItem(); + virtual void clear() = 0; + + virtual std::ostream &print(std::ostream &out, uint16_t /* indent */ = 0) + { + RsGenericSerializer::SerializeContext ctx(NULL,0,RsGenericSerializer::FORMAT_BINARY,RsGenericSerializer::SERIALIZATION_FLAG_NONE); + serial_process(RsGenericSerializer::PRINT,ctx) ; + return out; + } + + void print_string(std::string &out, uint16_t indent = 0); + + /* source / destination id */ + const RsPeerId& PeerId() const { return peerId; } + void PeerId(const RsPeerId& id) { peerId = id; } + + /* complete id */ + uint32_t PacketId() const; + + /* id parts */ + uint8_t PacketVersion(); + uint8_t PacketClass(); + uint8_t PacketType(); + uint8_t PacketSubType() const; + + /* For Service Packets */ + RsItem(uint8_t ver, uint16_t service, uint8_t subtype); + uint16_t PacketService() const; /* combined Packet class/type (mid 16bits) */ + void setPacketService(uint16_t service); + + inline uint8_t priority_level() const { return _priority_level ;} + inline void setPriorityLevel(uint8_t l) { _priority_level = l ;} + + /** + * @brief serialize this object to the given buffer + * @param Job to do: serialise or deserialize. + * @param data Chunk of memory were to dump the serialized data + * @param size Size of memory chunk + * @param offset Readed to determine at witch offset start writing data, + * written to inform caller were written data ends, the updated value + * is usually passed by the caller to serialize of another + * RsSerializable so it can write on the same chunk of memory just + * after where this RsSerializable has been serialized. + * @return true if serialization successed, false otherwise + */ + + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) + { + std::cerr << "(EE) RsItem::serial_process() called by an item using new serialization classes, but not derived! Class is " << typeid(*this).name() << std::endl; + } + + protected: + uint32_t type; + RsPeerId peerId; + uint8_t _priority_level ; +}; + +class RsRawItem: public RsItem +{ +public: + RsRawItem(uint32_t t, uint32_t size) : RsItem(t), len(size) + { data = rs_malloc(len); } + virtual ~RsRawItem() { free(data); } + + uint32_t getRawLength() { return len; } + void * getRawData() { return data; } + + virtual void clear() {} + virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + +private: + void *data; + uint32_t len; +}; diff --git a/libretroshare/src/rsitems/rsmsgitems.cc b/libretroshare/src/rsitems/rsmsgitems.cc index 8fd2f2c55..20c98ad1b 100644 --- a/libretroshare/src/rsitems/rsmsgitems.cc +++ b/libretroshare/src/rsitems/rsmsgitems.cc @@ -80,25 +80,25 @@ void RsMsgItem::clear() attachment.TlvClear(); } -void RsPublicMsgInviteConfigItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsPublicMsgInviteConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_SHA1,hash,"hash") ; RsTypeSerializer::serial_process(j,ctx,(uint32_t&)time_stamp,"time_stamp") ; } -void RsMsgTagType::serial_process(SerializeJob j,SerializeContext& ctx) +void RsMsgTagType::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_NAME,text,"text") ; RsTypeSerializer::serial_process(j,ctx,rgb_color,"rgb_color") ; RsTypeSerializer::serial_process(j,ctx,tagId,"tagId") ; } -void RsMsgTags::serial_process(SerializeJob j,SerializeContext& ctx) +void RsMsgTags::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,msgId,"msgId") ; #warning this is not the correct way to serialise here. We should directly call serial_process >() but for backward compatibility, we cannot - if(j == RsItem::DESERIALIZE) + if(j == RsGenericSerializer::DESERIALIZE) while(ctx.mOffset < ctx.mSize) { uint32_t n ; @@ -110,13 +110,13 @@ void RsMsgTags::serial_process(SerializeJob j,SerializeContext& ctx) RsTypeSerializer::serial_process(j,ctx,*it,"tagIds element") ; } -void RsMsgSrcId::serial_process(SerializeJob j,SerializeContext& ctx) +void RsMsgSrcId::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,msgId,"msgId") ; RsTypeSerializer::serial_process (j,ctx,srcId,"srcId") ; } -void RsMsgGRouterMap::serial_process(SerializeJob j,SerializeContext& ctx) +void RsMsgGRouterMap::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,ongoing_msgs,"ongoing_msgs") ; } @@ -128,18 +128,18 @@ void RsMsgGRouterMap::clear() return; } -void RsMsgDistantMessagesHashMap::serial_process(SerializeJob j,SerializeContext& ctx) +void RsMsgDistantMessagesHashMap::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,hash_map,"hash_map") ; } -void RsMsgParentId::serial_process(SerializeJob j,SerializeContext& ctx) +void RsMsgParentId::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,msgId,"msgId") ; RsTypeSerializer::serial_process(j,ctx,msgParentId,"msgParentId") ; } -void RsMsgItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,msgFlags,"msgFlags"); RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime"); diff --git a/libretroshare/src/rsitems/rsmsgitems.h b/libretroshare/src/rsitems/rsmsgitems.h index f0916352b..527c43fdf 100644 --- a/libretroshare/src/rsitems/rsmsgitems.h +++ b/libretroshare/src/rsitems/rsmsgitems.h @@ -101,7 +101,7 @@ class RsMsgItem: public RsMessageItem virtual ~RsMsgItem() {} virtual void clear(); - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); // ----------- Specific fields ------------- // @@ -130,7 +130,7 @@ class RsMsgTagType : public RsMessageItem public: RsMsgTagType() :RsMessageItem(RS_PKT_SUBTYPE_MSG_TAG_TYPE) {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); virtual ~RsMsgTagType() {} virtual void clear(); @@ -148,7 +148,7 @@ public: RsMsgTags() :RsMessageItem(RS_PKT_SUBTYPE_MSG_TAGS) {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); virtual ~RsMsgTags() {} virtual void clear(); @@ -164,7 +164,7 @@ class RsMsgSrcId : public RsMessageItem public: RsMsgSrcId() : RsMessageItem(RS_PKT_SUBTYPE_MSG_SRC_TAG) {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); virtual ~RsMsgSrcId() {} virtual void clear(){} @@ -180,7 +180,7 @@ class RsPublicMsgInviteConfigItem : public RsMessageItem public: RsPublicMsgInviteConfigItem() : RsMessageItem(RS_PKT_SUBTYPE_MSG_INVITE) {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); virtual ~RsPublicMsgInviteConfigItem() {} virtual void clear(); @@ -196,7 +196,7 @@ class RsMsgGRouterMap : public RsMessageItem public: RsMsgGRouterMap() : RsMessageItem(RS_PKT_SUBTYPE_MSG_GROUTER_MAP) {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); virtual ~RsMsgGRouterMap() {} virtual void clear(); @@ -210,7 +210,7 @@ class RsMsgDistantMessagesHashMap : public RsMessageItem public: RsMsgDistantMessagesHashMap() : RsMessageItem(RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP) {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); virtual ~RsMsgDistantMessagesHashMap() {} virtual void clear() { hash_map.clear() ;} @@ -224,7 +224,7 @@ class RsMsgParentId : public RsMessageItem public: RsMsgParentId() : RsMessageItem(RS_PKT_SUBTYPE_MSG_PARENT_TAG) {} - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */); + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); virtual ~RsMsgParentId() {} virtual void clear(){} @@ -239,7 +239,7 @@ class RsMsgSerialiser: public RsServiceSerializer { public: RsMsgSerialiser(SerializationFlags flags) - :RsServiceSerializer(RS_SERVICE_TYPE_MSG,SerializeContext::FORMAT_BINARY,flags){} + :RsServiceSerializer(RS_SERVICE_TYPE_MSG,RsGenericSerializer::FORMAT_BINARY,flags){} virtual ~RsMsgSerialiser() {} diff --git a/libretroshare/src/rsitems/rsrttitems.cc b/libretroshare/src/rsitems/rsrttitems.cc index ce2423dd4..2ab7292e5 100644 --- a/libretroshare/src/rsitems/rsrttitems.cc +++ b/libretroshare/src/rsitems/rsrttitems.cc @@ -32,6 +32,8 @@ #include +#include "serialization/rstypeserializer.h" + /*************************************************************************/ RsItem *RsRttSerialiser::create_item(uint16_t service,uint8_t type) const @@ -48,13 +50,13 @@ RsItem *RsRttSerialiser::create_item(uint16_t service,uint8_t type) const } } -void RsRttPingItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsRttPingItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,mSeqNo,"mSeqNo") ; RsTypeSerializer::serial_process(j,ctx,mPingTS,"mPingTS") ; } -void RsRttPongItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsRttPongItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,mSeqNo,"mSeqNo") ; RsTypeSerializer::serial_process(j,ctx,mPingTS,"mPingTS") ; diff --git a/libretroshare/src/rsitems/rsrttitems.h b/libretroshare/src/rsitems/rsrttitems.h index b3e5bdec2..8f635c3b9 100644 --- a/libretroshare/src/rsitems/rsrttitems.h +++ b/libretroshare/src/rsitems/rsrttitems.h @@ -28,7 +28,9 @@ #include +#include "rsitems/rsitem.h" #include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" #include "serialiser/rsserial.h" #include "serialization/rsserializer.h" @@ -56,7 +58,7 @@ class RsRttPingItem: public RsRttItem virtual ~RsRttPingItem(){} virtual void clear(){} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t mSeqNo; uint64_t mPingTS; @@ -70,7 +72,7 @@ class RsRttPongItem: public RsRttItem virtual ~RsRttPongItem(){} virtual void clear(){} - virtual void serial_process(SerializeJob j,SerializeContext& ctx); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t mSeqNo; uint64_t mPingTS; diff --git a/libretroshare/src/serialiser/rsgxsitems.h b/libretroshare/src/serialiser/rsgxsitems.h index ed6d3124d..74942d807 100644 --- a/libretroshare/src/serialiser/rsgxsitems.h +++ b/libretroshare/src/serialiser/rsgxsitems.h @@ -26,6 +26,7 @@ * */ +#include "rsitems/rsitem.h" #include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.h" diff --git a/libretroshare/src/serialiser/rsgxsrecognitems.h b/libretroshare/src/serialiser/rsgxsrecognitems.h index 6d0ea0ae6..aab0e3974 100644 --- a/libretroshare/src/serialiser/rsgxsrecognitems.h +++ b/libretroshare/src/serialiser/rsgxsrecognitems.h @@ -28,7 +28,10 @@ #include +#include "rsitems/rsitem.h" #include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" + #include "serialiser/rsserial.h" #include "serialiser/rstlvkeys.h" #include "serialiser/rstlvidset.h" diff --git a/libretroshare/src/serialiser/rsheartbeatitems.h b/libretroshare/src/serialiser/rsheartbeatitems.h index 5660ba373..3a9e6e95f 100644 --- a/libretroshare/src/serialiser/rsheartbeatitems.h +++ b/libretroshare/src/serialiser/rsheartbeatitems.h @@ -30,6 +30,8 @@ #include "serialiser/rsserial.h" #include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" const uint8_t RS_PKT_SUBTYPE_HEARTBEAT_PULSE = 0x01; diff --git a/libretroshare/src/serialiser/rsnxsitems.h b/libretroshare/src/serialiser/rsnxsitems.h index 259c560a6..2f4886507 100644 --- a/libretroshare/src/serialiser/rsnxsitems.h +++ b/libretroshare/src/serialiser/rsnxsitems.h @@ -31,6 +31,7 @@ #include #include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvitem.h" diff --git a/libretroshare/src/serialiser/rsserial.cc b/libretroshare/src/serialiser/rsserial.cc index 30fed530e..1436f92fa 100644 --- a/libretroshare/src/serialiser/rsserial.cc +++ b/libretroshare/src/serialiser/rsserial.cc @@ -25,11 +25,14 @@ */ #include "serialiser/rsbaseserial.h" -#include "serialiser/rsserial.h" + #include "util/rsthreads.h" #include "util/rsstring.h" #include "util/rsprint.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" + #include #include #include diff --git a/libretroshare/src/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index 511eec1c3..248c0a3bc 100644 --- a/libretroshare/src/serialiser/rsserial.h +++ b/libretroshare/src/serialiser/rsserial.h @@ -34,9 +34,6 @@ #include #include -#include "util/rsmemory.h" -#include "retroshare/rstypes.h" - /******************************************************************* * This is the Top-Level serialiser/deserialise, * @@ -59,9 +56,6 @@ * 8 bits: SubType ******************************************************************/ -#include -#include "rsitems/itempriorities.h" - const uint8_t RS_PKT_VERSION1 = 0x01; const uint8_t RS_PKT_VERSION_SERVICE = 0x02; @@ -70,74 +64,7 @@ const uint8_t RS_PKT_CLASS_CONFIG = 0x02; const uint8_t RS_PKT_SUBTYPE_DEFAULT = 0x01; /* if only one subtype */ -class SerializeContext ; - -class RsItem: public RsMemoryManagement::SmallObject -{ - public: - RsItem(uint32_t t); - RsItem(uint8_t ver, uint8_t cls, uint8_t t, uint8_t subtype); -#ifdef DO_STATISTICS - void *operator new(size_t s) ; - void operator delete(void *,size_t s) ; -#endif - - virtual ~RsItem(); - virtual void clear() = 0; - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0) - { - std::cerr << "(EE) RsItem::print() called by an item using new serialization classes, but not derived! " << std::endl; -#warning This method should normally call serial_process(PRINT,ctx) - return out; - } - void print_string(std::string &out, uint16_t indent = 0); - - /* source / destination id */ - const RsPeerId& PeerId() const { return peerId; } - void PeerId(const RsPeerId& id) { peerId = id; } - - /* complete id */ - uint32_t PacketId() const; - - /* id parts */ - uint8_t PacketVersion(); - uint8_t PacketClass(); - uint8_t PacketType(); - uint8_t PacketSubType() const; - - /* For Service Packets */ - RsItem(uint8_t ver, uint16_t service, uint8_t subtype); - uint16_t PacketService() const; /* combined Packet class/type (mid 16bits) */ - void setPacketService(uint16_t service); - - inline uint8_t priority_level() const { return _priority_level ;} - inline void setPriorityLevel(uint8_t l) { _priority_level = l ;} - - /** - * @brief serialize this object to the given buffer - * @param Job to do: serialise or deserialize. - * @param data Chunk of memory were to dump the serialized data - * @param size Size of memory chunk - * @param offset Readed to determine at witch offset start writing data, - * written to inform caller were written data ends, the updated value - * is usually passed by the caller to serialize of another - * RsSerializable so it can write on the same chunk of memory just - * after where this RsSerializable has been serialized. - * @return true if serialization successed, false otherwise - */ - typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03, PRINT=0x04 } SerializeJob ; - - virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */) - { - std::cerr << "(EE) RsItem::serial_process() called by an item using new serialization classes, but not derived! " << std::endl; - } - - protected: - uint32_t type; - RsPeerId peerId; - uint8_t _priority_level ; -}; - +class RsItem ; class RsSerialType { @@ -201,23 +128,4 @@ std::ostream &printRsItemEnd(std::ostream &o, std::string n, uint16_t i); std::ostream &printIndent(std::ostream &out, uint16_t indent); /* Wrapper class for data that is serialised somewhere else */ -class RsRawItem: public RsItem -{ -public: - RsRawItem(uint32_t t, uint32_t size) : RsItem(t), len(size) - { data = rs_malloc(len); } - virtual ~RsRawItem() { free(data); } - - uint32_t getRawLength() { return len; } - void * getRawData() { return data; } - - virtual void clear() {} - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); - -private: - void *data; - uint32_t len; -}; - - #endif /* RS_BASE_SERIALISER_H */ diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.h b/libretroshare/src/serialiser/rsserviceinfoitems.h index 76b451cce..b4c9beabe 100644 --- a/libretroshare/src/serialiser/rsserviceinfoitems.h +++ b/libretroshare/src/serialiser/rsserviceinfoitems.h @@ -31,6 +31,9 @@ #include #include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" + #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvgenericmap.h" diff --git a/libretroshare/src/serialiser/rsserviceserialiser.cc b/libretroshare/src/serialiser/rsserviceserialiser.cc index d99d03de1..0c953fec3 100644 --- a/libretroshare/src/serialiser/rsserviceserialiser.cc +++ b/libretroshare/src/serialiser/rsserviceserialiser.cc @@ -23,6 +23,7 @@ * */ +#include "rsitems/rsitem.h" #include "rsserviceserialiser.h" uint32_t RsServiceSerialiser::size(RsItem *i) diff --git a/libretroshare/src/serialiser/rsstatusitems.h b/libretroshare/src/serialiser/rsstatusitems.h index c6cc0c8b2..8ea99e04c 100644 --- a/libretroshare/src/serialiser/rsstatusitems.h +++ b/libretroshare/src/serialiser/rsstatusitems.h @@ -27,7 +27,8 @@ */ #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" +#include "rsitems/itempriorities.h" +#include "rsitems/rsitem.h" /**************************************************************************/ diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialization/rsserializer.cc index 3ab5770aa..f9619e839 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialization/rsserializer.cc @@ -1,5 +1,7 @@ #include +#include "rsitems/rsitem.h" + #include "util/rsprint.h" #include "serialization/rsserializer.h" #include "serialization/rstypeserializer.h" @@ -31,7 +33,7 @@ RsItem *RsServiceSerializer::deserialise(void *data, uint32_t *size) SerializeContext ctx(const_cast(static_cast(data)),*size,mFormat,mFlags); ctx.mOffset = 8 ; - item->serial_process(RsItem::DESERIALIZE, ctx) ; + item->serial_process(RsGenericSerializer::DESERIALIZE, ctx) ; if(ctx.mSize != ctx.mOffset) { @@ -67,7 +69,7 @@ RsItem *RsConfigSerializer::deserialise(void *data, uint32_t *size) SerializeContext ctx(const_cast(static_cast(data)),*size,mFormat,mFlags); ctx.mOffset = 8 ; - item->serial_process(RsItem::DESERIALIZE, ctx) ; + item->serial_process(DESERIALIZE, ctx) ; if(ctx.mSize != ctx.mOffset) { @@ -105,7 +107,7 @@ bool RsGenericSerializer::serialise(RsItem *item,void *data,uint32_t *size) ctx.mSize = tlvsize; - item->serial_process(RsItem::SERIALIZE,ctx) ; + item->serial_process(RsGenericSerializer::SERIALIZE,ctx) ; if(ctx.mSize != ctx.mOffset) { @@ -123,7 +125,7 @@ uint32_t RsGenericSerializer::size(RsItem *item) ctx.mOffset = 0; else ctx.mOffset = 8 ; // header size - item->serial_process(RsItem::SIZE_ESTIMATE, ctx) ; + item->serial_process(SIZE_ESTIMATE, ctx) ; return ctx.mOffset ; } @@ -133,7 +135,7 @@ void RsGenericSerializer::print(RsItem *item) SerializeContext ctx(NULL,0,mFormat,mFlags); std::cerr << "***** RsItem class: \"" << typeid(*item).name() << "\" *****" << std::endl; - item->serial_process(RsItem::PRINT, ctx) ; + item->serial_process(PRINT, ctx) ; std::cerr << "******************************" << std::endl; } diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialization/rsserializer.h index 700b690f5..2bea8d23f 100644 --- a/libretroshare/src/serialization/rsserializer.h +++ b/libretroshare/src/serialization/rsserializer.h @@ -5,15 +5,34 @@ #include #include +#include "retroshare/rsflags.h" #include "serialiser/rsserial.h" -#include "serialization/rstypeserializer.h" + +class RsItem ; #define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " class RsGenericSerializer: public RsSerialType { public: + typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03, PRINT=0x04 } SerializeJob ; + typedef enum { FORMAT_BINARY = 0x01, FORMAT_JSON = 0x02 } SerializationFormat ; + class SerializeContext + { + public: + + + SerializeContext(uint8_t *data,uint32_t size,SerializationFormat format,SerializationFlags flags) + : mData(data),mSize(size),mOffset(0),mOk(true),mFormat(format),mFlags(flags) {} + + unsigned char *mData ; + uint32_t mSize ; + uint32_t mOffset ; + bool mOk ; + SerializationFormat mFormat ; + SerializationFlags mFlags ; + }; // These are convenience flags to be used by the items when processing the data. The names of the flags // are not very important. What matters is that the serial_process() method of each item correctly @@ -36,18 +55,18 @@ public: protected: RsGenericSerializer(uint8_t serial_class, uint8_t serial_type, - SerializeContext::SerializationFormat format, + SerializationFormat format, SerializationFlags flags ) : RsSerialType(RS_PKT_VERSION1,serial_class,serial_type), mFormat(format),mFlags(flags) {} RsGenericSerializer(uint16_t service, - SerializeContext::SerializationFormat format, + SerializationFormat format, SerializationFlags flags ) : RsSerialType(RS_PKT_VERSION_SERVICE,service), mFormat(format),mFlags(flags) {} - SerializeContext::SerializationFormat mFormat ; + SerializationFormat mFormat ; SerializationFlags mFlags ; }; @@ -56,8 +75,8 @@ class RsServiceSerializer: public RsGenericSerializer { public: RsServiceSerializer(uint16_t service_id, - SerializeContext::SerializationFormat format = SerializeContext::FORMAT_BINARY, - SerializationFlags flags = SERIALIZATION_FLAG_NONE) + SerializationFormat format = FORMAT_BINARY, + SerializationFlags flags = SERIALIZATION_FLAG_NONE) : RsGenericSerializer(service_id,format,flags) {} @@ -74,8 +93,8 @@ class RsConfigSerializer: public RsGenericSerializer public: RsConfigSerializer(uint8_t config_class, uint8_t config_type, - SerializeContext::SerializationFormat format = SerializeContext::FORMAT_BINARY, - SerializationFlags flags = RsGenericSerializer::SERIALIZATION_FLAG_NONE) + SerializationFormat format = FORMAT_BINARY, + SerializationFlags flags = SERIALIZATION_FLAG_NONE) : RsGenericSerializer(config_class,config_type,format,flags) {} diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 0693331b1..31da447f4 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -7,25 +7,7 @@ #include "retroshare/rsflags.h" #include "retroshare/rsids.h" -class SerializeContext -{ - public: - - enum SerializationFormat { - FORMAT_BINARY = 0x01 , - FORMAT_JSON = 0x02 - }; - - SerializeContext(uint8_t *data,uint32_t size,SerializationFormat format,SerializationFlags flags) - : mData(data),mSize(size),mOffset(0),mOk(true),mFormat(format),mFlags(flags) {} - - unsigned char *mData ; - uint32_t mSize ; - uint32_t mOffset ; - bool mOk ; - SerializationFormat mFormat ; - SerializationFlags mFlags ; -}; +#include "serialization/rsserializer.h" class RsTypeSerializer @@ -44,20 +26,20 @@ class RsTypeSerializer //=================================================================================================// template - static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member,const std::string& member_name) + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,T& member,const std::string& member_name) { switch(j) { - case RsItem::SIZE_ESTIMATE: ctx.mOffset += serial_size(member) ; + case RsGenericSerializer::SIZE_ESTIMATE: ctx.mOffset += serial_size(member) ; break ; - case RsItem::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + case RsGenericSerializer::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; break ; - case RsItem::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + case RsGenericSerializer::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; break ; - case RsItem::PRINT: + case RsGenericSerializer::PRINT: print_data(member_name,member); break; default: @@ -71,20 +53,20 @@ class RsTypeSerializer //=================================================================================================// template - static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,uint16_t type_id,T& member,const std::string& member_name) + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,uint16_t type_id,T& member,const std::string& member_name) { switch(j) { - case RsItem::SIZE_ESTIMATE: ctx.mOffset += serial_size(type_id,member) ; + case RsGenericSerializer::SIZE_ESTIMATE: ctx.mOffset += serial_size(type_id,member) ; break ; - case RsItem::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,type_id,member) ; + case RsGenericSerializer::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,type_id,member) ; break ; - case RsItem::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,type_id,member) ; + case RsGenericSerializer::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,type_id,member) ; break ; - case RsItem::PRINT: + case RsGenericSerializer::PRINT: print_data(member_name,type_id,member); break; default: @@ -97,11 +79,11 @@ class RsTypeSerializer //=================================================================================================// template - static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,std::map& v,const std::string& member_name) + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,std::map& v,const std::string& member_name) { switch(j) { - case RsItem::SIZE_ESTIMATE: + case RsGenericSerializer::SIZE_ESTIMATE: { ctx.mOffset += 4 ; for(typename std::map::iterator it(v.begin());it!=v.end();++it) @@ -112,7 +94,7 @@ class RsTypeSerializer } break ; - case RsItem::DESERIALIZE: + case RsGenericSerializer::DESERIALIZE: { uint32_t n=0 ; ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; @@ -130,7 +112,7 @@ class RsTypeSerializer } break ; - case RsItem::SERIALIZE: + case RsGenericSerializer::SERIALIZE: { uint32_t n=v.size(); ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; @@ -143,12 +125,12 @@ class RsTypeSerializer } break ; - case RsItem::PRINT: + case RsGenericSerializer::PRINT: { if(v.empty()) - std::cerr << " Empty map"<< std::endl; + std::cerr << " Empty map \"" << member_name << "\"" << std::endl; else - std::cerr << " std::map of " << v.size() << " elements:" << std::endl; + std::cerr << " std::map of " << v.size() << " elements: \"" << member_name << "\"" << std::endl; for(typename std::map::iterator it(v.begin());it!=v.end();++it) { @@ -169,11 +151,11 @@ class RsTypeSerializer //=================================================================================================// template - static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,std::vector& v,const std::string& member_name) + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,std::vector& v,const std::string& member_name) { switch(j) { - case RsItem::SIZE_ESTIMATE: + case RsGenericSerializer::SIZE_ESTIMATE: { ctx.mOffset += 4 ; for(uint32_t i=0;i - static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,std::list& v,const std::string& member_name) + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,std::list& v,const std::string& member_name) { switch(j) { - case RsItem::SIZE_ESTIMATE: + case RsGenericSerializer::SIZE_ESTIMATE: { ctx.mOffset += 4 ; for(typename std::list::iterator it(v.begin());it!=v.end();++it) @@ -235,7 +217,7 @@ class RsTypeSerializer } break ; - case RsItem::DESERIALIZE: + case RsGenericSerializer::DESERIALIZE: { uint32_t n=0 ; serial_process(j,ctx,n,"temporary size") ; @@ -248,7 +230,7 @@ class RsTypeSerializer } break ; - case RsItem::SERIALIZE: + case RsGenericSerializer::SERIALIZE: { uint32_t n=v.size(); serial_process(j,ctx,n,"temporary size") ; @@ -257,7 +239,7 @@ class RsTypeSerializer } break ; - case RsItem::PRINT: + case RsGenericSerializer::PRINT: { if(v.empty()) std::cerr << " Empty list"<< std::endl; @@ -275,14 +257,14 @@ class RsTypeSerializer //=================================================================================================// template - static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,t_RsFlags32& v,const std::string& member_name) + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,t_RsFlags32& v,const std::string& member_name) { switch(j) { - case RsItem::SIZE_ESTIMATE: ctx.mOffset += 4 ; + case RsGenericSerializer::SIZE_ESTIMATE: ctx.mOffset += 4 ; break ; - case RsItem::DESERIALIZE: + case RsGenericSerializer::DESERIALIZE: { uint32_t n=0 ; deserialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; @@ -290,14 +272,14 @@ class RsTypeSerializer } break ; - case RsItem::SERIALIZE: + case RsGenericSerializer::SERIALIZE: { uint32_t n=v.toUInt32() ; serialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; } break ; - case RsItem::PRINT: + case RsGenericSerializer::PRINT: std::cerr << " Flags of type " << std::hex << N << " : " << v.toUInt32() << std::endl; break ; } diff --git a/libretroshare/src/services/p3service.cc b/libretroshare/src/services/p3service.cc index 469247905..bb15831d7 100644 --- a/libretroshare/src/services/p3service.cc +++ b/libretroshare/src/services/p3service.cc @@ -23,6 +23,8 @@ * */ +#include "rsitems/itempriorities.h" + #include "pqi/pqi.h" #include "util/rsstring.h" #include "services/p3service.h" diff --git a/libretroshare/src/turtle/rsturtleitem.cc b/libretroshare/src/turtle/rsturtleitem.cc index 4d5f1a2fa..2455c98e5 100644 --- a/libretroshare/src/turtle/rsturtleitem.cc +++ b/libretroshare/src/turtle/rsturtleitem.cc @@ -48,14 +48,14 @@ RsItem *RsTurtleSerialiser::create_item(uint16_t service,uint8_t item_subtype) c return NULL ; } -void RsTurtleStringSearchRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleStringSearchRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_VALUE,match_string,"match_string") ; RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; RsTypeSerializer::serial_process(j,ctx,depth ,"depth") ; } -void RsTurtleRegExpSearchRequestItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleRegExpSearchRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; RsTypeSerializer::serial_process(j,ctx,depth,"depth") ; @@ -140,7 +140,7 @@ template<> void RsTypeSerializer::print_data(const std::string& n, const RsRegul std::cerr << " [RegExpr ] " << n << ", tokens=" << expr._tokens.size() << " ints=" << expr._ints.size() << " strings=" << expr._strings.size() << std::endl; } -void RsTurtleSearchResultItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleSearchResultItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; RsTypeSerializer::serial_process(j,ctx,depth ,"depth") ; @@ -193,7 +193,7 @@ template<> void RsTypeSerializer::print_data(const std::string& n, const TurtleF std::cerr << " [FileInfo ] " << n << " size=" << i.size << " hash=" << i.hash << ", name=" << i.name << std::endl; } -void RsTurtleOpenTunnelItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleOpenTunnelItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,file_hash ,"file_hash") ; RsTypeSerializer::serial_process(j,ctx,request_id ,"request_id") ; @@ -201,13 +201,13 @@ void RsTurtleOpenTunnelItem::serial_process(SerializeJob j,SerializeContext& ctx RsTypeSerializer::serial_process(j,ctx,depth ,"depth") ; } -void RsTurtleTunnelOkItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleTunnelOkItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id ,"tunnel_id") ; RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; } -void RsTurtleGenericDataItem::serial_process(SerializeJob j,SerializeContext& ctx) +void RsTurtleGenericDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,tunnel_id ,"tunnel_id") ; diff --git a/libretroshare/src/turtle/rsturtleitem.h b/libretroshare/src/turtle/rsturtleitem.h index 9bc3fc4bf..8a8a1e49c 100644 --- a/libretroshare/src/turtle/rsturtleitem.h +++ b/libretroshare/src/turtle/rsturtleitem.h @@ -1,12 +1,16 @@ #pragma once +#include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" + #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rsbaseserial.h" + #include "retroshare/rsturtle.h" #include "retroshare/rsexpr.h" #include "retroshare/rstypes.h" -#include "rsitems/rsserviceids.h" #include "turtle/turtletypes.h" #include "serialization/rsserializer.h" @@ -58,7 +62,7 @@ class RsTurtleSearchResultItem: public RsTurtleItem void clear() { result.clear() ; } protected: - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; @@ -87,7 +91,7 @@ class RsTurtleStringSearchRequestItem: public RsTurtleSearchRequestItem void clear() { match_string.clear() ; } protected: - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; class RsTurtleRegExpSearchRequestItem: public RsTurtleSearchRequestItem @@ -102,7 +106,7 @@ class RsTurtleRegExpSearchRequestItem: public RsTurtleSearchRequestItem void clear() { expr = RsRegularExpression::LinearizedExpression(); } protected: - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; /***********************************************************************************/ @@ -121,7 +125,7 @@ class RsTurtleOpenTunnelItem: public RsTurtleItem void clear() { file_hash.clear() ;} protected: - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; class RsTurtleTunnelOkItem: public RsTurtleItem @@ -134,7 +138,7 @@ class RsTurtleTunnelOkItem: public RsTurtleItem void clear() {} protected: - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; /***********************************************************************************/ @@ -198,7 +202,7 @@ class RsTurtleGenericDataItem: public RsTurtleGenericTunnelItem data_size = 0; } protected: - void serial_process(SerializeJob j,SerializeContext& ctx); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; /***********************************************************************************/ From fb34fa19c02e417397f1b9984be3037eff02d091 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 13:44:09 +0200 Subject: [PATCH 50/94] switch GxsComment item to new serialization --- .../src/serialiser/rsgxscommentitems.cc | 32 +++++++++++++ .../src/serialiser/rsgxscommentitems.h | 46 ++++++------------- 2 files changed, 46 insertions(+), 32 deletions(-) diff --git a/libretroshare/src/serialiser/rsgxscommentitems.cc b/libretroshare/src/serialiser/rsgxscommentitems.cc index 11832701e..4f655cc13 100644 --- a/libretroshare/src/serialiser/rsgxscommentitems.cc +++ b/libretroshare/src/serialiser/rsgxscommentitems.cc @@ -28,9 +28,25 @@ #include "rsgxscommentitems.h" #include "serialiser/rstlvbase.h" #include "serialiser/rsbaseserial.h" +#include "serialization/rstypeserializer.h" //#define GXSCOMMENT_DEBUG 1 +RsItem *RsGxsCommentSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const +{ + if(service_id != getRsItemService(PacketId())) + return NULL ; + + switch(item_subtype) + { + case RS_PKT_SUBTYPE_GXSCOMMENT_COMMENT_ITEM: return new RsGxsCommentItem(getRsItemService(PacketId())) ; + case RS_PKT_SUBTYPE_GXSCOMMENT_VOTE_ITEM: return new RsGxsVoteItem(getRsItemService(PacketId())); + default: + return NULL ; + } +} + +#ifdef TO_REMOVE uint32_t RsGxsCommentSerialiser::size(RsItem *item) { @@ -152,7 +168,15 @@ uint32_t RsGxsCommentSerialiser::sizeGxsCommentItem(RsGxsCommentItem *item) return s; } +#endif + +void RsGxsCommentItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,1,mMsg.mComment,"mMsg.mComment") ; +} + +#ifdef TO_REMOVE bool RsGxsCommentSerialiser::serialiseGxsCommentItem(RsGxsCommentItem *item, void *data, uint32_t *size) { @@ -297,7 +321,14 @@ uint32_t RsGxsCommentSerialiser::sizeGxsVoteItem(RsGxsVoteItem */*item*/) return s; } +#endif +void RsGxsVoteItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mMsg.mVoteType,"mMsg.mVoteType") ; +} + +#ifdef TO_REMOVE bool RsGxsCommentSerialiser::serialiseGxsVoteItem(RsGxsVoteItem *item, void *data, uint32_t *size) { @@ -414,3 +445,4 @@ RsGxsVoteItem* RsGxsCommentSerialiser::deserialiseGxsVoteItem(void *data, uint32 /*****************************************************************************************/ /*****************************************************************************************/ +#endif diff --git a/libretroshare/src/serialiser/rsgxscommentitems.h b/libretroshare/src/serialiser/rsgxscommentitems.h index 2ccd6d5d8..37171ce94 100644 --- a/libretroshare/src/serialiser/rsgxscommentitems.h +++ b/libretroshare/src/serialiser/rsgxscommentitems.h @@ -43,54 +43,36 @@ class RsGxsCommentItem : public RsGxsMsgItem { public: - RsGxsCommentItem(uint16_t service_type): RsGxsMsgItem(service_type, - RS_PKT_SUBTYPE_GXSCOMMENT_COMMENT_ITEM) {return; } - virtual ~RsGxsCommentItem() { return;} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsCommentItem(uint16_t service_type): RsGxsMsgItem(service_type, RS_PKT_SUBTYPE_GXSCOMMENT_COMMENT_ITEM) {} + virtual ~RsGxsCommentItem() {} + void clear(){} + + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); RsGxsComment mMsg; }; - class RsGxsVoteItem : public RsGxsMsgItem { public: - RsGxsVoteItem(uint16_t service_type): RsGxsMsgItem(service_type, - RS_PKT_SUBTYPE_GXSCOMMENT_VOTE_ITEM) {return; } - virtual ~RsGxsVoteItem() { return;} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsVoteItem(uint16_t service_type): RsGxsMsgItem(service_type, RS_PKT_SUBTYPE_GXSCOMMENT_VOTE_ITEM) {} + virtual ~RsGxsVoteItem() {} + void clear(){} + + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); RsGxsVote mMsg; }; - -class RsGxsCommentSerialiser : public RsSerialType +class RsGxsCommentSerialiser : public RsServiceSerializer { public: - RsGxsCommentSerialiser(uint16_t service_type) - :RsSerialType(RS_PKT_VERSION_SERVICE, service_type) - { return; } - virtual ~RsGxsCommentSerialiser() { return; } - - uint32_t size(RsItem *item); - bool serialise (RsItem *item, void *data, uint32_t *size); - RsItem * deserialise(void *data, uint32_t *size); - - private: - - uint32_t sizeGxsCommentItem(RsGxsCommentItem *item); - bool serialiseGxsCommentItem (RsGxsCommentItem *item, void *data, uint32_t *size); - RsGxsCommentItem * deserialiseGxsCommentItem(void *data, uint32_t *size); - - - uint32_t sizeGxsVoteItem(RsGxsVoteItem *item); - bool serialiseGxsVoteItem (RsGxsVoteItem *item, void *data, uint32_t *size); - RsGxsVoteItem * deserialiseGxsVoteItem(void *data, uint32_t *size); + RsGxsCommentSerialiser(uint16_t service_type) :RsServiceSerializer(service_type) {} + virtual ~RsGxsCommentSerialiser() {} + RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; }; #endif /* RS_GXS_COMMENT_ITEMS_H */ From c0d8735251a3f2c25191bc461ed60f587c286818 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 14:17:38 +0200 Subject: [PATCH 51/94] switched RsGxsIdItems to new serialization --- libretroshare/src/serialiser/rsgxsiditems.cc | 70 ++++++++++++++----- libretroshare/src/serialiser/rsgxsiditems.h | 49 ++----------- .../src/serialization/rstypeserializer.h | 52 ++++++++++++++ 3 files changed, 110 insertions(+), 61 deletions(-) diff --git a/libretroshare/src/serialiser/rsgxsiditems.cc b/libretroshare/src/serialiser/rsgxsiditems.cc index f5019b7f4..2daa65a49 100644 --- a/libretroshare/src/serialiser/rsgxsiditems.cc +++ b/libretroshare/src/serialiser/rsgxsiditems.cc @@ -31,8 +31,36 @@ #include "serialiser/rstlvstring.h" #include "util/rsstring.h" +#include "serialization/rstypeserializer.h" + #define GXSID_DEBUG 1 +RsItem *RsGxsIdSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const +{ + if(service_id != RS_SERVICE_GXS_TYPE_GXSID) + return NULL ; + + switch(item_subtype) + { + case RS_PKT_SUBTYPE_GXSID_GROUP_ITEM : return new RsGxsIdGroupItem (); + case RS_PKT_SUBTYPE_GXSID_LOCAL_INFO_ITEM: return new RsGxsIdLocalInfoItem() ; + default: + return NULL ; + } +} +void RsGxsIdLocalInfoItem::clear() +{ + mTimeStamps.clear() ; +} +void RsGxsIdGroupItem::clear() +{ + mPgpIdHash.clear(); + mPgpIdSign.clear(); + + mRecognTags.clear(); + mImage.TlvClear(); +} +#ifdef TO_REMOVE RsItem* RsGxsIdSerialiser::deserialise(void* data, uint32_t* size) { /* get the type and size */ @@ -84,18 +112,8 @@ bool RsGxsIdItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsiz /*****************************************************************************************/ -void RsGxsIdLocalInfoItem::clear() -{ - mTimeStamps.clear() ; -} -void RsGxsIdGroupItem::clear() -{ - mPgpIdHash.clear(); - mPgpIdSign.clear(); - mRecognTags.clear(); - mImage.TlvClear(); -} + uint32_t RsGxsIdLocalInfoItem::serial_size() { uint32_t s = 8 ; // header @@ -160,8 +178,15 @@ uint32_t RsGxsIdGroupItem::serial_size() return s; } +#endif +void RsGxsIdLocalInfoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mTimeStamps,"mTimeStamps") ; + RsTypeSerializer::serial_process(j,ctx,mContacts,"mContacts") ; +} +#ifdef TO_REMOVE bool RsGxsIdLocalInfoItem::serialise(void *data, uint32_t& size) { uint32_t tlvsize,offset=0; @@ -199,7 +224,20 @@ bool RsGxsIdLocalInfoItem::serialise(void *data, uint32_t& size) return ok; } +#endif +void RsGxsIdGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mPgpIdHash,"mPgpIdHash") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_SIGN,mPgpIdSign,"mPgpIdSign") ; + + RsTlvStringSetRef rset(TLV_TYPE_RECOGNSET,mRecognTags) ; + + RsTypeSerializer::serial_process(j,ctx,rset,"mRecognTags") ; + RsTypeSerializer::serial_process(j,ctx,mImage,"mImage") ; +} + +#ifdef TO_REMOVE bool RsGxsIdGroupItem::serialise(void *data, uint32_t& size) { uint32_t tlvsize,offset=0; @@ -234,7 +272,7 @@ bool RsGxsIdGroupItem::serialise(void *data, uint32_t& size) return ok; } - +#endif bool RsGxsIdGroupItem::fromGxsIdGroup(RsGxsIdGroup &group, bool moveImage) { @@ -275,6 +313,8 @@ bool RsGxsIdGroupItem::toGxsIdGroup(RsGxsIdGroup &group, bool moveImage) } return true ; } + +#ifdef TO_REMOVE RsGxsIdGroupItem* RsGxsIdSerialiser::deserialise_GxsIdGroupItem(void *data, uint32_t *size) { /* get the type and size */ @@ -427,6 +467,7 @@ RsGxsIdLocalInfoItem *RsGxsIdSerialiser::deserialise_GxsIdLocalInfoItem(void *da return item; } +#endif /*****************************************************************************************/ @@ -692,8 +733,3 @@ RsGxsIdCommentItem* RsGxsIdSerialiser::deserialise_GxsIdCommentItem(void *data, } #endif - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - diff --git a/libretroshare/src/serialiser/rsgxsiditems.h b/libretroshare/src/serialiser/rsgxsiditems.h index 39ca6882a..19802a9a1 100644 --- a/libretroshare/src/serialiser/rsgxsiditems.h +++ b/libretroshare/src/serialiser/rsgxsiditems.h @@ -45,14 +45,6 @@ class RsGxsIdItem: public RsGxsGrpItem { public: RsGxsIdItem(uint8_t item_subtype) : RsGxsGrpItem(RS_SERVICE_GXS_TYPE_GXSID,item_subtype) {} - - virtual bool serialise(void *data,uint32_t& size) = 0 ; - virtual uint32_t serial_size() = 0 ; - - virtual void clear() = 0 ; - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0; - - bool serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) ; }; class RsGxsIdGroupItem : public RsGxsIdItem @@ -62,11 +54,8 @@ public: RsGxsIdGroupItem(): RsGxsIdItem(RS_PKT_SUBTYPE_GXSID_GROUP_ITEM) {} virtual ~RsGxsIdGroupItem() {} + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); - - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; bool fromGxsIdGroup(RsGxsIdGroup &group, bool moveImage); bool toGxsIdGroup(RsGxsIdGroup &group, bool moveImage); @@ -91,10 +80,8 @@ public: virtual ~RsGxsIdLocalInfoItem() {} virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); std::map mTimeStamps ; std::set mContacts ; @@ -133,39 +120,13 @@ public: }; #endif -class RsGxsIdSerialiser : public RsSerialType +class RsGxsIdSerialiser : public RsServiceSerializer { public: - RsGxsIdSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_GXSID) {} + RsGxsIdSerialiser() :RsServiceSerializer(RS_SERVICE_GXS_TYPE_GXSID) {} virtual ~RsGxsIdSerialiser() {} - virtual uint32_t size (RsItem *item) - { - RsGxsIdItem *idItem = dynamic_cast(item); - if (!idItem) - { - return 0; - } - return idItem->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - RsGxsIdItem *idItem = dynamic_cast(item); - if (!idItem) - { - return false; - } - return idItem->serialise(data,*size) ; - } - virtual RsItem *deserialise (void *data, uint32_t *size) ; - -private: -#if 0 - static RsGxsIdOpinionItem *deserialise_GxsIdOpinionItem(void *data, uint32_t *size); - static RsGxsIdCommentItem *deserialise_GxsIdCommentItem(void *data, uint32_t *size); -#endif - static RsGxsIdGroupItem *deserialise_GxsIdGroupItem(void *data, uint32_t *size); - static RsGxsIdLocalInfoItem *deserialise_GxsIdLocalInfoItem(void *data, uint32_t *size); + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; }; #endif /* RS_GXS_IDENTITY_ITEMS_H */ diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 31da447f4..5ff9f4944 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -199,6 +199,58 @@ class RsTypeSerializer break; } } + //=================================================================================================// + // std::set // + //=================================================================================================// + + template + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,std::set& v,const std::string& member_name) + { + switch(j) + { + case RsGenericSerializer::SIZE_ESTIMATE: + { + ctx.mOffset += 4 ; + for(typename std::set::iterator it(v.begin());it!=v.end();++it) + serial_process(j,ctx,const_cast(*it) ,member_name) ; + } + break ; + + case RsGenericSerializer::DESERIALIZE: + { uint32_t n=0 ; + serial_process(j,ctx,n,"temporary size") ; + + for(uint32_t i=0;i(j,ctx,tmp,member_name) ; + v.insert(tmp); + } + } + break ; + + case RsGenericSerializer::SERIALIZE: + { + uint32_t n=v.size(); + serial_process(j,ctx,n,"temporary size") ; + for(typename std::set::iterator it(v.begin());it!=v.end();++it) + serial_process(j,ctx,const_cast(*it) ,member_name) ; + } + break ; + + case RsGenericSerializer::PRINT: + { + if(v.empty()) + std::cerr << " Empty set"<< std::endl; + else + std::cerr << " Set of " << v.size() << " elements:" << std::endl; + } + break; + default: + break; + } + } + //=================================================================================================// // std::list // From 97d0df0737f522bf7511bb6b616b17efeae646ec Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 14:19:34 +0200 Subject: [PATCH 52/94] added comment about serialization hack --- libretroshare/src/serialization/rstypeserializer.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 5ff9f4944..3da545df8 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -212,7 +212,7 @@ class RsTypeSerializer { ctx.mOffset += 4 ; for(typename std::set::iterator it(v.begin());it!=v.end();++it) - serial_process(j,ctx,const_cast(*it) ,member_name) ; + serial_process(j,ctx,const_cast(*it) ,member_name) ; // the const cast here is a hack to avoid serial_process to instantiate serialise(const T&) } break ; @@ -234,7 +234,7 @@ class RsTypeSerializer uint32_t n=v.size(); serial_process(j,ctx,n,"temporary size") ; for(typename std::set::iterator it(v.begin());it!=v.end();++it) - serial_process(j,ctx,const_cast(*it) ,member_name) ; + serial_process(j,ctx,const_cast(*it) ,member_name) ; // the const cast here is a hack to avoid serial_process to instantiate serialise(const T&) } break ; From 508a2e2864aaa6bcd848d7dc54d6016c947c6cfb Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 14:28:25 +0200 Subject: [PATCH 53/94] moved gxs comment and Id items to rsitems/ --- libretroshare/src/gxs/rsgds.h | 2 +- libretroshare/src/gxs/rsgxsdata.h | 25 +++++++++---------- libretroshare/src/libretroshare.pro | 12 ++++----- .../rsgxscommentitems.cc | 0 .../rsgxscommentitems.h | 0 .../{serialiser => rsitems}/rsgxsiditems.cc | 0 .../{serialiser => rsitems}/rsgxsiditems.h | 0 .../src/{serialiser => rsitems}/rsgxsitems.cc | 0 .../src/{serialiser => rsitems}/rsgxsitems.h | 0 .../src/serialiser/rsgxschannelitems.h | 8 +++--- .../src/serialiser/rsgxscircleitems.h | 4 +-- .../src/serialiser/rsgxsforumitems.h | 4 +-- libretroshare/src/serialiser/rsposteditems.h | 7 ++---- libretroshare/src/services/p3gxscommon.cc | 2 +- libretroshare/src/services/p3idservice.cc | 2 +- libretroshare/src/services/p3idservice.h | 2 +- libretroshare/src/services/p3postbase.cc | 2 +- 17 files changed, 31 insertions(+), 39 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsgxscommentitems.cc (100%) rename libretroshare/src/{serialiser => rsitems}/rsgxscommentitems.h (100%) rename libretroshare/src/{serialiser => rsitems}/rsgxsiditems.cc (100%) rename libretroshare/src/{serialiser => rsitems}/rsgxsiditems.h (100%) rename libretroshare/src/{serialiser => rsitems}/rsgxsitems.cc (100%) rename libretroshare/src/{serialiser => rsitems}/rsgxsitems.h (100%) diff --git a/libretroshare/src/gxs/rsgds.h b/libretroshare/src/gxs/rsgds.h index c56b47c12..5a82337fe 100644 --- a/libretroshare/src/gxs/rsgds.h +++ b/libretroshare/src/gxs/rsgds.h @@ -32,7 +32,7 @@ #include "inttypes.h" -#include "serialiser/rsgxsitems.h" +#include "rsitems/rsgxsitems.h" #include "serialiser/rsnxsitems.h" #include "gxs/rsgxsdata.h" #include "rsgxs.h" diff --git a/libretroshare/src/gxs/rsgxsdata.h b/libretroshare/src/gxs/rsgxsdata.h index 21fbe1445..6e85193dc 100644 --- a/libretroshare/src/gxs/rsgxsdata.h +++ b/libretroshare/src/gxs/rsgxsdata.h @@ -29,10 +29,9 @@ #include #include - -#include "serialiser/rsserial.h" #include "serialiser/rstlvkeys.h" -#include "serialiser/rsgxsitems.h" + +#include "rsitems/rsgxsitems.h" class RsGroupMetaData; class RsMsgMetaData; @@ -56,22 +55,22 @@ public: void clear(); void operator =(const RsGroupMetaData& rMeta); - //Sort data in same order than serialiser and deserializer + //Sort data in same order than serialiser and deserializer RsGxsGroupId mGroupId; RsGxsGroupId mOrigGrpId; - RsGxsGroupId mParentGrpId; + RsGxsGroupId mParentGrpId; std::string mGroupName; uint32_t mGroupFlags; // GXS_SERV::FLAG_PRIVACY_RESTRICTED | GXS_SERV::FLAG_PRIVACY_PRIVATE | GXS_SERV::FLAG_PRIVACY_PUBLIC uint32_t mPublishTs; - uint32_t mCircleType; - uint32_t mAuthenFlags; + uint32_t mCircleType; + uint32_t mAuthenFlags; RsGxsId mAuthorId; - std::string mServiceString; + std::string mServiceString; RsGxsCircleId mCircleId; RsTlvKeySignatureSet signSet; RsTlvSecurityKeySet keys; - uint32_t mSignFlags; + uint32_t mSignFlags; // BELOW HERE IS LOCAL DATA, THAT IS NOT FROM MSG. @@ -103,9 +102,9 @@ public: void clear(); void operator =(const RsMsgMetaData& rMeta); - static int refcount; - - //Sort data in same order than serialiser and deserializer + static int refcount; + + //Sort data in same order than serialiser and deserializer RsGxsGroupId mGroupId; RsGxsMessageId mMsgId; RsGxsMessageId mThreadId; @@ -121,7 +120,7 @@ public: // BELOW HERE IS LOCAL DATA, THAT IS NOT FROM MSG. // normally READ / UNREAD flags. LOCAL Data. - std::string mServiceString; + std::string mServiceString; uint32_t mMsgStatus; uint32_t mMsgSize; time_t mChildTs; diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 287e6a4d7..aa2aecf9e 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -735,7 +735,7 @@ HEADERS += serialiser/rsnxsitems.h \ retroshare/rstokenservice.h \ gxs/rsgxsdataaccess.h \ retroshare/rsgxsservice.h \ - serialiser/rsgxsitems.h \ + rsitems/rsgxsitems.h \ util/retrodb.h \ util/rsdbbind.h \ gxs/rsgxsutil.h \ @@ -753,7 +753,7 @@ SOURCES += serialiser/rsnxsitems.cc \ gxs/rsgenexchange.cc \ gxs/rsgxsnetservice.cc \ gxs/rsgxsdata.cc \ - serialiser/rsgxsitems.cc \ + rsitems/rsgxsitems.cc \ gxs/rsgxsdataaccess.cc \ util/retrodb.cc \ util/contentvalue.cc \ @@ -783,12 +783,12 @@ SOURCES += serialization/rsserializer.cc \ HEADERS += retroshare/rsidentity.h \ gxs/rsgixs.h \ services/p3idservice.h \ - serialiser/rsgxsiditems.h \ + rsitems/rsgxsiditems.h \ services/p3gxsreputation.h \ rsitems/rsgxsreputationitems.h \ SOURCES += services/p3idservice.cc \ - serialiser/rsgxsiditems.cc \ + rsitems/rsgxsiditems.cc \ services/p3gxsreputation.cc \ rsitems/rsgxsreputationitems.cc \ @@ -812,12 +812,12 @@ SOURCES += services/p3gxsforums.cc \ HEADERS += retroshare/rsgxschannels.h \ services/p3gxschannels.h \ services/p3gxscommon.h \ - serialiser/rsgxscommentitems.h \ + rsitems/rsgxscommentitems.h \ serialiser/rsgxschannelitems.h \ SOURCES += services/p3gxschannels.cc \ services/p3gxscommon.cc \ - serialiser/rsgxscommentitems.cc \ + rsitems/rsgxscommentitems.cc \ serialiser/rsgxschannelitems.cc \ wikipoos { diff --git a/libretroshare/src/serialiser/rsgxscommentitems.cc b/libretroshare/src/rsitems/rsgxscommentitems.cc similarity index 100% rename from libretroshare/src/serialiser/rsgxscommentitems.cc rename to libretroshare/src/rsitems/rsgxscommentitems.cc diff --git a/libretroshare/src/serialiser/rsgxscommentitems.h b/libretroshare/src/rsitems/rsgxscommentitems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxscommentitems.h rename to libretroshare/src/rsitems/rsgxscommentitems.h diff --git a/libretroshare/src/serialiser/rsgxsiditems.cc b/libretroshare/src/rsitems/rsgxsiditems.cc similarity index 100% rename from libretroshare/src/serialiser/rsgxsiditems.cc rename to libretroshare/src/rsitems/rsgxsiditems.cc diff --git a/libretroshare/src/serialiser/rsgxsiditems.h b/libretroshare/src/rsitems/rsgxsiditems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxsiditems.h rename to libretroshare/src/rsitems/rsgxsiditems.h diff --git a/libretroshare/src/serialiser/rsgxsitems.cc b/libretroshare/src/rsitems/rsgxsitems.cc similarity index 100% rename from libretroshare/src/serialiser/rsgxsitems.cc rename to libretroshare/src/rsitems/rsgxsitems.cc diff --git a/libretroshare/src/serialiser/rsgxsitems.h b/libretroshare/src/rsitems/rsgxsitems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxsitems.h rename to libretroshare/src/rsitems/rsgxsitems.h diff --git a/libretroshare/src/serialiser/rsgxschannelitems.h b/libretroshare/src/serialiser/rsgxschannelitems.h index 9a937e581..51939d576 100644 --- a/libretroshare/src/serialiser/rsgxschannelitems.h +++ b/libretroshare/src/serialiser/rsgxschannelitems.h @@ -29,14 +29,12 @@ #include #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" +#include "rsitems/rsgxscommentitems.h" +#include "rsitems/rsgxsitems.h" + #include "serialiser/rstlvfileitem.h" #include "serialiser/rstlvimage.h" -#include "serialiser/rsgxscommentitems.h" - -#include "rsgxsitems.h" #include "retroshare/rsgxschannels.h" #include "util/rsdir.h" diff --git a/libretroshare/src/serialiser/rsgxscircleitems.h b/libretroshare/src/serialiser/rsgxscircleitems.h index 84316b133..ba28f2782 100644 --- a/libretroshare/src/serialiser/rsgxscircleitems.h +++ b/libretroshare/src/serialiser/rsgxscircleitems.h @@ -29,12 +29,12 @@ #include #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" + #include "serialiser/rstlvitem.h" #include "serialiser/rstlvstring.h" #include "serialiser/rstlvidset.h" -#include "rsgxsitems.h" +#include "rsitems/rsgxsitems.h" #include "retroshare/rsgxscircles.h" const uint8_t RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM = 0x02; diff --git a/libretroshare/src/serialiser/rsgxsforumitems.h b/libretroshare/src/serialiser/rsgxsforumitems.h index 97f6dd89b..22fae7e63 100644 --- a/libretroshare/src/serialiser/rsgxsforumitems.h +++ b/libretroshare/src/serialiser/rsgxsforumitems.h @@ -29,10 +29,8 @@ #include #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" +#include "rsitems/rsgxsitems.h" -#include "rsgxsitems.h" #include "retroshare/rsgxsforums.h" const uint8_t RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM = 0x02; diff --git a/libretroshare/src/serialiser/rsposteditems.h b/libretroshare/src/serialiser/rsposteditems.h index a303f0d33..e78dfafe1 100644 --- a/libretroshare/src/serialiser/rsposteditems.h +++ b/libretroshare/src/serialiser/rsposteditems.h @@ -2,12 +2,9 @@ #define RSPOSTEDITEMS_H #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" +#include "rsitems/rsgxscommentitems.h" +#include "rsitems/rsgxsitems.h" -#include "serialiser/rsgxscommentitems.h" - -#include "rsgxsitems.h" #include "retroshare/rsposted.h" const uint8_t RS_PKT_SUBTYPE_POSTED_GRP_ITEM = 0x02; diff --git a/libretroshare/src/services/p3gxscommon.cc b/libretroshare/src/services/p3gxscommon.cc index ad97f1eca..822c19cdf 100644 --- a/libretroshare/src/services/p3gxscommon.cc +++ b/libretroshare/src/services/p3gxscommon.cc @@ -25,7 +25,7 @@ #include "retroshare/rsgxscommon.h" #include "services/p3gxscommon.h" -#include "serialiser/rsgxscommentitems.h" +#include "rsitems/rsgxscommentitems.h" #include "util/rsstring.h" #include diff --git a/libretroshare/src/services/p3idservice.cc b/libretroshare/src/services/p3idservice.cc index c173dba8a..37c609373 100644 --- a/libretroshare/src/services/p3idservice.cc +++ b/libretroshare/src/services/p3idservice.cc @@ -27,7 +27,7 @@ #include "services/p3idservice.h" #include "pgp/pgpauxutils.h" -#include "serialiser/rsgxsiditems.h" +#include "rsitems/rsgxsiditems.h" #include "rsitems/rsconfigitems.h" #include "retroshare/rsgxsflags.h" #include "util/rsrandom.h" diff --git a/libretroshare/src/services/p3idservice.h b/libretroshare/src/services/p3idservice.h index addff0d1b..caf29ee73 100644 --- a/libretroshare/src/services/p3idservice.h +++ b/libretroshare/src/services/p3idservice.h @@ -32,7 +32,7 @@ #include "gxs/rsgixs.h" // Internal Interfaces. #include "gxs/gxstokenqueue.h" -#include "serialiser/rsgxsiditems.h" +#include "rsitems/rsgxsiditems.h" #include #include diff --git a/libretroshare/src/services/p3postbase.cc b/libretroshare/src/services/p3postbase.cc index cb3c43fc1..077104db0 100644 --- a/libretroshare/src/services/p3postbase.cc +++ b/libretroshare/src/services/p3postbase.cc @@ -30,7 +30,7 @@ #include #include "services/p3postbase.h" -#include "serialiser/rsgxscommentitems.h" +#include "rsitems/rsgxscommentitems.h" #include "rsserver/p3face.h" #include "retroshare/rsnotify.h" From c31396a010883c4d98a80bcabf37e1536e48e534 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 14:31:15 +0200 Subject: [PATCH 54/94] moved dsdv code to unused directory --- libretroshare/src/libretroshare.pro | 14 +++++++------- libretroshare/src/{services => unused}/p3dsdv.cc | 0 libretroshare/src/{services => unused}/p3dsdv.h | 0 libretroshare/src/{retroshare => unused}/rsdsdv.h | 0 .../src/{serialiser => unused}/rsdsdvitems.cc | 0 .../src/{serialiser => unused}/rsdsdvitems.h | 0 6 files changed, 7 insertions(+), 7 deletions(-) rename libretroshare/src/{services => unused}/p3dsdv.cc (100%) rename libretroshare/src/{services => unused}/p3dsdv.h (100%) rename libretroshare/src/{retroshare => unused}/rsdsdv.h (100%) rename libretroshare/src/{serialiser => unused}/rsdsdvitems.cc (100%) rename libretroshare/src/{serialiser => unused}/rsdsdvitems.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index aa2aecf9e..781228027 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -61,14 +61,14 @@ file_lists { dsdv { DEFINES *= SERVICES_DSDV -HEADERS += services/p3dsdv.h \ - serialiser/rstlvdsdv.h \ - serialiser/rsdsdvitems.h \ - retroshare/rsdsdv.h +HEADERS += unused/p3dsdv.h \ + unused/rstlvdsdv.h \ + unused/rsdsdvitems.h \ + unused/rsdsdv.h -SOURCES *= serialiser/rstlvdsdv.cc \ - serialiser/rsdsdvitems.cc \ - services/p3dsdv.cc +SOURCES *= unused/rstlvdsdv.cc \ + unused/rsdsdvitems.cc \ + unused/p3dsdv.cc } bitdht { diff --git a/libretroshare/src/services/p3dsdv.cc b/libretroshare/src/unused/p3dsdv.cc similarity index 100% rename from libretroshare/src/services/p3dsdv.cc rename to libretroshare/src/unused/p3dsdv.cc diff --git a/libretroshare/src/services/p3dsdv.h b/libretroshare/src/unused/p3dsdv.h similarity index 100% rename from libretroshare/src/services/p3dsdv.h rename to libretroshare/src/unused/p3dsdv.h diff --git a/libretroshare/src/retroshare/rsdsdv.h b/libretroshare/src/unused/rsdsdv.h similarity index 100% rename from libretroshare/src/retroshare/rsdsdv.h rename to libretroshare/src/unused/rsdsdv.h diff --git a/libretroshare/src/serialiser/rsdsdvitems.cc b/libretroshare/src/unused/rsdsdvitems.cc similarity index 100% rename from libretroshare/src/serialiser/rsdsdvitems.cc rename to libretroshare/src/unused/rsdsdvitems.cc diff --git a/libretroshare/src/serialiser/rsdsdvitems.h b/libretroshare/src/unused/rsdsdvitems.h similarity index 100% rename from libretroshare/src/serialiser/rsdsdvitems.h rename to libretroshare/src/unused/rsdsdvitems.h From 8f97647246ec30080436a8c8fb8d30743dd97895 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 15:43:00 +0200 Subject: [PATCH 55/94] fixed bug in RsGxsId deserialization --- libretroshare/src/gxs/rsgenexchange.cc | 3 ++- libretroshare/src/rsitems/rsgxsiditems.cc | 6 ++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/libretroshare/src/gxs/rsgenexchange.cc b/libretroshare/src/gxs/rsgenexchange.cc index a334f7e3d..c59da85de 100644 --- a/libretroshare/src/gxs/rsgenexchange.cc +++ b/libretroshare/src/gxs/rsgenexchange.cc @@ -1323,7 +1323,8 @@ bool RsGenExchange::getGroupData(const uint32_t &token, std::vector 0) - std::cerr << "(EE) RsGenExchange::getGroupData() Item type is probably not handled. Data is: " << RsUtil::BinToHex((unsigned char*)data.bin_data,std::min(50u,data.bin_len)) << ((data.bin_len>50)?"...":"") << std::endl; + //std::cerr << "(EE) RsGenExchange::getGroupData() Item type is probably not handled. Data is: " << RsUtil::BinToHex((unsigned char*)data.bin_data,std::min(50u,data.bin_len)) << ((data.bin_len>50)?"...":"") << std::endl; + std::cerr << "(EE) RsGenExchange::getGroupData() Item type is probably not handled. Data is: " << RsUtil::BinToHex((unsigned char*)data.bin_data,data.bin_len) << std::endl; delete *lit; } diff --git a/libretroshare/src/rsitems/rsgxsiditems.cc b/libretroshare/src/rsitems/rsgxsiditems.cc index 2daa65a49..cb5ed324e 100644 --- a/libretroshare/src/rsitems/rsgxsiditems.cc +++ b/libretroshare/src/rsitems/rsgxsiditems.cc @@ -234,6 +234,12 @@ void RsGxsIdGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGene RsTlvStringSetRef rset(TLV_TYPE_RECOGNSET,mRecognTags) ; RsTypeSerializer::serial_process(j,ctx,rset,"mRecognTags") ; + + // image is optional + + if(j == RsGenericSerializer::DESERIALIZE && ctx.mOffset == ctx.mSize) + return ; + RsTypeSerializer::serial_process(j,ctx,mImage,"mImage") ; } From 77c2e6da8c80d1f762264bc86a753c5f897b4a64 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 18:14:10 +0200 Subject: [PATCH 56/94] improved error handlign in pqistore --- libretroshare/src/pqi/pqistore.cc | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/libretroshare/src/pqi/pqistore.cc b/libretroshare/src/pqi/pqistore.cc index 23201541a..7372529b1 100644 --- a/libretroshare/src/pqi/pqistore.cc +++ b/libretroshare/src/pqi/pqistore.cc @@ -310,24 +310,25 @@ int pqistore::readPkt(RsItem **item_out) } // workout how much more to read. - int extralen = getRsItemSize(block) - blen; - int totallen = extralen+blen; - - // make sure that totallen is not a crazy number. If so, we drop the entire stream that might be corrupted. - - if(totallen > 1024*1024) + int blocklength = getRsItemSize(block); + + // make sure that blocklength is not a crazy number. If so, we drop the entire stream that might be corrupted. + + if(blocklength < blen || blocklength > 1024*1024*10) { - std::cerr << "pqistore: ERROR: trying to realloc memory for packet of length" << totallen <<", which exceeds the allowed limit (1MB)" << std::endl ; + std::cerr << "pqistore: ERROR: trying to realloc memory for packet of length" << blocklength <<", which is either too small, or exceeds the safety limit (10 MB)" << std::endl ; free(block) ; bStopReading=true; return 0 ; } - void *tmp = realloc(block, totallen); + int extralen = blocklength - blen; + + void *tmp = realloc(block, blocklength); if (tmp == NULL) { free(block); - std::cerr << "pqistore: ERROR: trying to realloc memory for packet of length" << totallen << std::endl ; + std::cerr << "pqistore: ERROR: trying to realloc memory for packet of length" << blocklength << std::endl ; std::cerr << "Have you got enought memory?" << std::endl ; bStopReading=true; return 0 ; @@ -522,17 +523,18 @@ int pqiSSLstore::readPkt(RsItem **item_out) } // workout how much more to read. - int extralen = getRsItemSize(block) - blen; - int totallen = extralen+blen; + int blocklength = getRsItemSize(block); - if(totallen > 1024*1024 || totallen 1024*1024*10) { free(block); - std::cerr << "pqiSSLstore: ERROR: trying to realloc memory for packet of length" << totallen << ", that exceeds the limit of 1MB" << std::endl ; + std::cerr << "pqiSSLstore: ERROR: block length has invalid value " << blocklength << " (either too small, or exceeds the safety limit of 10 MB)" << std::endl ; bStopReading=true; return 0 ; } - void *tmp = realloc(block, totallen); + int extralen = blocklength - blen; + + void *tmp = realloc(block, blocklength); if (tmp == NULL) { From 69729ad7d2f6c9f049221627953fdd780f0fa1b9 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 18:55:23 +0200 Subject: [PATCH 57/94] switch Channel items to new serialization --- libretroshare/src/rsitems/rsgxscommentitems.h | 2 +- .../src/serialiser/rsgxschannelitems.cc | 78 ++++++++++++++----- .../src/serialiser/rsgxschannelitems.h | 46 ++++------- 3 files changed, 74 insertions(+), 52 deletions(-) diff --git a/libretroshare/src/rsitems/rsgxscommentitems.h b/libretroshare/src/rsitems/rsgxscommentitems.h index 37171ce94..dcb89e2de 100644 --- a/libretroshare/src/rsitems/rsgxscommentitems.h +++ b/libretroshare/src/rsitems/rsgxscommentitems.h @@ -72,7 +72,7 @@ public: RsGxsCommentSerialiser(uint16_t service_type) :RsServiceSerializer(service_type) {} virtual ~RsGxsCommentSerialiser() {} - RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; }; #endif /* RS_GXS_COMMENT_ITEMS_H */ diff --git a/libretroshare/src/serialiser/rsgxschannelitems.cc b/libretroshare/src/serialiser/rsgxschannelitems.cc index bad8a0a98..f540fffd7 100644 --- a/libretroshare/src/serialiser/rsgxschannelitems.cc +++ b/libretroshare/src/serialiser/rsgxschannelitems.cc @@ -29,9 +29,25 @@ #include "serialiser/rstlvbase.h" #include "serialiser/rsbaseserial.h" +#include "serialization/rstypeserializer.h" + //#define GXSCHANNEL_DEBUG 1 +RsItem *RsGxsChannelSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const +{ + if(service_id != RS_SERVICE_GXS_TYPE_CHANNELS) + return NULL ; + switch(item_subtype) + { + case RS_PKT_SUBTYPE_GXSCHANNEL_GROUP_ITEM: return new RsGxsChannelGroupItem() ; + case RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM: return new RsGxsChannelPostItem(); + default: + return RsGxsCommentSerialiser::create_item(service_id,item_subtype) ; + } +} + +#ifdef TO_REMOVE uint32_t RsGxsChannelSerialiser::size(RsItem *item) { #ifdef GXSCHANNEL_DEBUG @@ -113,19 +129,6 @@ RsItem* RsGxsChannelSerialiser::deserialise(void* data, uint32_t* size) return NULL; } - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsChannelGroupItem::clear() -{ - mDescription.clear(); - mImage.TlvClear(); -} - std::ostream& RsGxsChannelGroupItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsChannelGroupItem", indent); @@ -141,6 +144,19 @@ std::ostream& RsGxsChannelGroupItem::print(std::ostream& out, uint16_t indent) return out; } +#endif + +/*****************************************************************************************/ +/*****************************************************************************************/ +/*****************************************************************************************/ + + +void RsGxsChannelGroupItem::clear() +{ + mDescription.clear(); + mImage.TlvClear(); +} + bool RsGxsChannelGroupItem::fromChannelGroup(RsGxsChannelGroup &group, bool moveImage) @@ -181,6 +197,7 @@ bool RsGxsChannelGroupItem::toChannelGroup(RsGxsChannelGroup &group, bool moveIm return true; } +#ifdef TO_REMOVE uint32_t RsGxsChannelSerialiser::sizeGxsChannelGroupItem(RsGxsChannelGroupItem *item) { @@ -191,7 +208,15 @@ uint32_t RsGxsChannelSerialiser::sizeGxsChannelGroupItem(RsGxsChannelGroupItem * return s; } +#endif +void RsGxsChannelGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_DESCR,mDescription,"mDescription") ; + RsTypeSerializer::serial_process(j,ctx,mImage,"mImage") ; +} + +#ifdef TO_REMOVE bool RsGxsChannelSerialiser::serialiseGxsChannelGroupItem(RsGxsChannelGroupItem *item, void *data, uint32_t *size) { @@ -312,14 +337,6 @@ RsGxsChannelGroupItem* RsGxsChannelSerialiser::deserialiseGxsChannelGroupItem(vo /*****************************************************************************************/ /*****************************************************************************************/ - -void RsGxsChannelPostItem::clear() -{ - mMsg.clear(); - mAttachment.TlvClear(); - mThumbnail.TlvClear(); -} - std::ostream& RsGxsChannelPostItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsChannelPostItem", indent); @@ -337,6 +354,7 @@ std::ostream& RsGxsChannelPostItem::print(std::ostream& out, uint16_t indent) printRsItemEnd(out ,"RsGxsChannelPostItem", indent); return out; } +#endif bool RsGxsChannelPostItem::fromChannelPost(RsGxsChannelPost &post, bool moveImage) @@ -402,6 +420,14 @@ bool RsGxsChannelPostItem::toChannelPost(RsGxsChannelPost &post, bool moveImage) return true; } +void RsGxsChannelPostItem::clear() +{ + mMsg.clear(); + mAttachment.TlvClear(); + mThumbnail.TlvClear(); +} + +#ifdef TO_REMOVE uint32_t RsGxsChannelSerialiser::sizeGxsChannelPostItem(RsGxsChannelPostItem *item) { @@ -413,7 +439,16 @@ uint32_t RsGxsChannelSerialiser::sizeGxsChannelPostItem(RsGxsChannelPostItem *it return s; } +#endif +void RsGxsChannelPostItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_MSG,mMsg,"mMsg") ; + RsTypeSerializer::serial_process(j,ctx,mAttachment,"mAttachment") ; + RsTypeSerializer::serial_process(j,ctx,mThumbnail,"mThumbnail") ; +} + +#ifdef TO_REMOVE bool RsGxsChannelSerialiser::serialiseGxsChannelPostItem(RsGxsChannelPostItem *item, void *data, uint32_t *size) { @@ -533,4 +568,5 @@ RsGxsChannelPostItem* RsGxsChannelSerialiser::deserialiseGxsChannelPostItem(void /*****************************************************************************************/ /*****************************************************************************************/ /*****************************************************************************************/ +#endif diff --git a/libretroshare/src/serialiser/rsgxschannelitems.h b/libretroshare/src/serialiser/rsgxschannelitems.h index 51939d576..b4caf5197 100644 --- a/libretroshare/src/serialiser/rsgxschannelitems.h +++ b/libretroshare/src/serialiser/rsgxschannelitems.h @@ -37,22 +37,23 @@ #include "retroshare/rsgxschannels.h" +#include "serialization/rsserializer.h" + #include "util/rsdir.h" const uint8_t RS_PKT_SUBTYPE_GXSCHANNEL_GROUP_ITEM = 0x02; -const uint8_t RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM = 0x03; +const uint8_t RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM = 0x03; class RsGxsChannelGroupItem : public RsGxsGrpItem { - public: - RsGxsChannelGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_CHANNELS, - RS_PKT_SUBTYPE_GXSCHANNEL_GROUP_ITEM) { return;} - virtual ~RsGxsChannelGroupItem() { return;} + RsGxsChannelGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_CHANNELS, RS_PKT_SUBTYPE_GXSCHANNEL_GROUP_ITEM) {} + virtual ~RsGxsChannelGroupItem() {} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // use conversion functions to transform: bool fromChannelGroup(RsGxsChannelGroup &group, bool moveImage); @@ -66,11 +67,11 @@ class RsGxsChannelPostItem : public RsGxsMsgItem { public: - RsGxsChannelPostItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_CHANNELS, - RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM) {return; } - virtual ~RsGxsChannelPostItem() { return;} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsChannelPostItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_CHANNELS, RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM) {} + virtual ~RsGxsChannelPostItem() {} + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // Slightly unusual structure. // use conversion functions to transform: @@ -87,25 +88,10 @@ class RsGxsChannelSerialiser : public RsGxsCommentSerialiser { public: - RsGxsChannelSerialiser() - :RsGxsCommentSerialiser(RS_SERVICE_GXS_TYPE_CHANNELS) - { return; } - virtual ~RsGxsChannelSerialiser() { return; } - - uint32_t size(RsItem *item); - bool serialise (RsItem *item, void *data, uint32_t *size); - RsItem * deserialise(void *data, uint32_t *size); - - private: - - uint32_t sizeGxsChannelGroupItem(RsGxsChannelGroupItem *item); - bool serialiseGxsChannelGroupItem (RsGxsChannelGroupItem *item, void *data, uint32_t *size); - RsGxsChannelGroupItem * deserialiseGxsChannelGroupItem(void *data, uint32_t *size); - - uint32_t sizeGxsChannelPostItem(RsGxsChannelPostItem *item); - bool serialiseGxsChannelPostItem (RsGxsChannelPostItem *item, void *data, uint32_t *size); - RsGxsChannelPostItem * deserialiseGxsChannelPostItem(void *data, uint32_t *size); + RsGxsChannelSerialiser() :RsGxsCommentSerialiser(RS_SERVICE_GXS_TYPE_CHANNELS) {} + virtual ~RsGxsChannelSerialiser() {} + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; }; #endif /* RS_GXS_CHANNEL_ITEMS_H */ From db645239cbb9c90733c4a95f89c44fe18a354378 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 20:15:54 +0200 Subject: [PATCH 58/94] moved rsgxschannel items to rsitems --- libretroshare/src/libretroshare.pro | 4 +- .../src/rsitems/rsgxschannelitems.cc | 173 ++++++ .../rsgxschannelitems.h | 0 libretroshare/src/rsitems/rsgxscommentitems.h | 3 +- libretroshare/src/rsitems/rsgxsitems.h | 4 +- .../src/serialiser/rsgxschannelitems.cc | 572 ------------------ 6 files changed, 177 insertions(+), 579 deletions(-) create mode 100644 libretroshare/src/rsitems/rsgxschannelitems.cc rename libretroshare/src/{serialiser => rsitems}/rsgxschannelitems.h (100%) delete mode 100644 libretroshare/src/serialiser/rsgxschannelitems.cc diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 781228027..d13df8213 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -813,12 +813,12 @@ HEADERS += retroshare/rsgxschannels.h \ services/p3gxschannels.h \ services/p3gxscommon.h \ rsitems/rsgxscommentitems.h \ - serialiser/rsgxschannelitems.h \ + rsitems/rsgxschannelitems.h \ SOURCES += services/p3gxschannels.cc \ services/p3gxscommon.cc \ rsitems/rsgxscommentitems.cc \ - serialiser/rsgxschannelitems.cc \ + rsitems/rsgxschannelitems.cc \ wikipoos { # Wiki Service diff --git a/libretroshare/src/rsitems/rsgxschannelitems.cc b/libretroshare/src/rsitems/rsgxschannelitems.cc new file mode 100644 index 000000000..789357b4c --- /dev/null +++ b/libretroshare/src/rsitems/rsgxschannelitems.cc @@ -0,0 +1,173 @@ +/* + * libretroshare/src/serialiser: rsgxschannelitems.cc + * + * RetroShare C++ Interface. + * + * Copyright 2012-2012 by Robert Fernie + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2.1 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include "rsgxschannelitems.h" +#include "serialiser/rstlvbase.h" +#include "serialiser/rsbaseserial.h" + +#include "serialization/rstypeserializer.h" + +RsItem *RsGxsChannelSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const +{ + if(service_id != RS_SERVICE_GXS_TYPE_CHANNELS) + return NULL ; + + switch(item_subtype) + { + case RS_PKT_SUBTYPE_GXSCHANNEL_GROUP_ITEM: return new RsGxsChannelGroupItem() ; + case RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM: return new RsGxsChannelPostItem(); + default: + return RsGxsCommentSerialiser::create_item(service_id,item_subtype) ; + } +} + +void RsGxsChannelGroupItem::clear() +{ + mDescription.clear(); + mImage.TlvClear(); +} + +bool RsGxsChannelGroupItem::fromChannelGroup(RsGxsChannelGroup &group, bool moveImage) +{ + clear(); + meta = group.mMeta; + mDescription = group.mDescription; + + if (moveImage) + { + mImage.binData.bin_data = group.mImage.mData; + mImage.binData.bin_len = group.mImage.mSize; + group.mImage.shallowClear(); + } + else + { + mImage.binData.setBinData(group.mImage.mData, group.mImage.mSize); + } + return true; +} + + + +bool RsGxsChannelGroupItem::toChannelGroup(RsGxsChannelGroup &group, bool moveImage) +{ + group.mMeta = meta; + group.mDescription = mDescription; + if (moveImage) + { + group.mImage.take((uint8_t *) mImage.binData.bin_data, mImage.binData.bin_len); + // mImage doesn't have a ShallowClear at the moment! + mImage.binData.TlvShallowClear(); + } + else + { + group.mImage.copy((uint8_t *) mImage.binData.bin_data, mImage.binData.bin_len); + } + return true; +} + +void RsGxsChannelGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_DESCR,mDescription,"mDescription") ; + RsTypeSerializer::serial_process(j,ctx,mImage,"mImage") ; +} + +bool RsGxsChannelPostItem::fromChannelPost(RsGxsChannelPost &post, bool moveImage) +{ + clear(); + meta = post.mMeta; + mMsg = post.mMsg; + + if (moveImage) + { + mThumbnail.binData.bin_data = post.mThumbnail.mData; + mThumbnail.binData.bin_len = post.mThumbnail.mSize; + post.mThumbnail.shallowClear(); + } + else + { + mThumbnail.binData.setBinData(post.mThumbnail.mData, post.mThumbnail.mSize); + } + + std::list::iterator fit; + for(fit = post.mFiles.begin(); fit != post.mFiles.end(); ++fit) + { + RsTlvFileItem fi; + fi.name = fit->mName; + fi.filesize = fit->mSize; + fi.hash = fit->mHash; + mAttachment.items.push_back(fi); + } + return true; +} + + + +bool RsGxsChannelPostItem::toChannelPost(RsGxsChannelPost &post, bool moveImage) +{ + post.mMeta = meta; + post.mMsg = mMsg; + if (moveImage) + { + post.mThumbnail.take((uint8_t *) mThumbnail.binData.bin_data, mThumbnail.binData.bin_len); + // mThumbnail doesn't have a ShallowClear at the moment! + mThumbnail.binData.TlvShallowClear(); + } + else + { + post.mThumbnail.copy((uint8_t *) mThumbnail.binData.bin_data, mThumbnail.binData.bin_len); + } + + post.mCount = 0; + post.mSize = 0; + std::list::iterator fit; + for(fit = mAttachment.items.begin(); fit != mAttachment.items.end(); ++fit) + { + RsGxsFile fi; + fi.mName = RsDirUtil::getTopDir(fit->name); + fi.mSize = fit->filesize; + fi.mHash = fit->hash; + + post.mFiles.push_back(fi); + post.mCount++; + post.mSize += fi.mSize; + } + return true; +} + +void RsGxsChannelPostItem::clear() +{ + mMsg.clear(); + mAttachment.TlvClear(); + mThumbnail.TlvClear(); +} + +void RsGxsChannelPostItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_MSG,mMsg,"mMsg") ; + RsTypeSerializer::serial_process(j,ctx,mAttachment,"mAttachment") ; + RsTypeSerializer::serial_process(j,ctx,mThumbnail,"mThumbnail") ; +} diff --git a/libretroshare/src/serialiser/rsgxschannelitems.h b/libretroshare/src/rsitems/rsgxschannelitems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxschannelitems.h rename to libretroshare/src/rsitems/rsgxschannelitems.h diff --git a/libretroshare/src/rsitems/rsgxscommentitems.h b/libretroshare/src/rsitems/rsgxscommentitems.h index dcb89e2de..ec5d6ae2c 100644 --- a/libretroshare/src/rsitems/rsgxscommentitems.h +++ b/libretroshare/src/rsitems/rsgxscommentitems.h @@ -29,8 +29,6 @@ #include #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" #include "rsgxsitems.h" @@ -52,6 +50,7 @@ public: RsGxsComment mMsg; }; + class RsGxsVoteItem : public RsGxsMsgItem { public: diff --git a/libretroshare/src/rsitems/rsgxsitems.h b/libretroshare/src/rsitems/rsgxsitems.h index 74942d807..026cbca08 100644 --- a/libretroshare/src/rsitems/rsgxsitems.h +++ b/libretroshare/src/rsitems/rsgxsitems.h @@ -28,9 +28,7 @@ #include "rsitems/rsitem.h" #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" -//#include "serialiser/rstlvkeys.h" + #include "retroshare/rsgxsifacetypes.h" std::ostream &operator<<(std::ostream &out, const RsGroupMetaData &meta); diff --git a/libretroshare/src/serialiser/rsgxschannelitems.cc b/libretroshare/src/serialiser/rsgxschannelitems.cc deleted file mode 100644 index f540fffd7..000000000 --- a/libretroshare/src/serialiser/rsgxschannelitems.cc +++ /dev/null @@ -1,572 +0,0 @@ -/* - * libretroshare/src/serialiser: rsgxschannelitems.cc - * - * RetroShare C++ Interface. - * - * Copyright 2012-2012 by Robert Fernie - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License Version 2.1 as published by the Free Software Foundation. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA. - * - * Please report all bugs and problems to "retroshare@lunamutt.com". - * - */ - -#include - -#include "rsgxschannelitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" - -#include "serialization/rstypeserializer.h" - -//#define GXSCHANNEL_DEBUG 1 - -RsItem *RsGxsChannelSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const -{ - if(service_id != RS_SERVICE_GXS_TYPE_CHANNELS) - return NULL ; - - switch(item_subtype) - { - case RS_PKT_SUBTYPE_GXSCHANNEL_GROUP_ITEM: return new RsGxsChannelGroupItem() ; - case RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM: return new RsGxsChannelPostItem(); - default: - return RsGxsCommentSerialiser::create_item(service_id,item_subtype) ; - } -} - -#ifdef TO_REMOVE -uint32_t RsGxsChannelSerialiser::size(RsItem *item) -{ -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::size()" << std::endl; -#endif - - RsGxsChannelGroupItem* grp_item = NULL; - RsGxsChannelPostItem* op_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return sizeGxsChannelGroupItem(grp_item); - } - else if((op_item = dynamic_cast(item)) != NULL) - { - return sizeGxsChannelPostItem(op_item); - } - else - { - return RsGxsCommentSerialiser::size(item); - } - return 0; -} - -bool RsGxsChannelSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::serialise()" << std::endl; -#endif - - RsGxsChannelGroupItem* grp_item = NULL; - RsGxsChannelPostItem* op_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsChannelGroupItem(grp_item, data, size); - } - else if((op_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsChannelPostItem(op_item, data, size); - } - else - { - return RsGxsCommentSerialiser::serialise(item, data, size); - } -} - -RsItem* RsGxsChannelSerialiser::deserialise(void* data, uint32_t* size) -{ - -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_CHANNELS != getRsItemService(rstype))) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialise() ERROR Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_GXSCHANNEL_GROUP_ITEM: - return deserialiseGxsChannelGroupItem(data, size); - break; - case RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM: - return deserialiseGxsChannelPostItem(data, size); - break; - default: - return RsGxsCommentSerialiser::deserialise(data, size); - break; - } - return NULL; -} - -std::ostream& RsGxsChannelGroupItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsChannelGroupItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Description: " << mDescription << std::endl; - - out << "Image: " << std::endl; - mImage.print(out, int_Indent); - - printRsItemEnd(out ,"RsGxsChannelGroupItem", indent); - return out; -} - -#endif - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsChannelGroupItem::clear() -{ - mDescription.clear(); - mImage.TlvClear(); -} - - - -bool RsGxsChannelGroupItem::fromChannelGroup(RsGxsChannelGroup &group, bool moveImage) -{ - clear(); - meta = group.mMeta; - mDescription = group.mDescription; - - if (moveImage) - { - mImage.binData.bin_data = group.mImage.mData; - mImage.binData.bin_len = group.mImage.mSize; - group.mImage.shallowClear(); - } - else - { - mImage.binData.setBinData(group.mImage.mData, group.mImage.mSize); - } - return true; -} - - - -bool RsGxsChannelGroupItem::toChannelGroup(RsGxsChannelGroup &group, bool moveImage) -{ - group.mMeta = meta; - group.mDescription = mDescription; - if (moveImage) - { - group.mImage.take((uint8_t *) mImage.binData.bin_data, mImage.binData.bin_len); - // mImage doesn't have a ShallowClear at the moment! - mImage.binData.TlvShallowClear(); - } - else - { - group.mImage.copy((uint8_t *) mImage.binData.bin_data, mImage.binData.bin_len); - } - return true; -} - -#ifdef TO_REMOVE - -uint32_t RsGxsChannelSerialiser::sizeGxsChannelGroupItem(RsGxsChannelGroupItem *item) -{ - uint32_t s = 8; // header - - s += GetTlvStringSize(item->mDescription); - s += item->mImage.TlvSize(); - - return s; -} -#endif - -void RsGxsChannelGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) -{ - RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_DESCR,mDescription,"mDescription") ; - RsTypeSerializer::serial_process(j,ctx,mImage,"mImage") ; -} - -#ifdef TO_REMOVE -bool RsGxsChannelSerialiser::serialiseGxsChannelGroupItem(RsGxsChannelGroupItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelGroupItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsChannelGroupItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelGroupItem() Size too small" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsChannelGroupItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DESCR, item->mDescription); - item->mImage.SetTlv(data, tlvsize, &offset); - - if(offset != tlvsize) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelGroupItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSCHANNEL_DEBUG - if (!ok) - { - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelGroupItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsChannelGroupItem* RsGxsChannelSerialiser::deserialiseGxsChannelGroupItem(void *data, uint32_t *size) -{ - -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelGroupItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_CHANNELS != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSCHANNEL_GROUP_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelGroupItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelGroupItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsChannelGroupItem* item = new RsGxsChannelGroupItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DESCR, item->mDescription); - item->mImage.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelGroupItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelGroupItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -std::ostream& RsGxsChannelPostItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsChannelPostItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Msg: " << mMsg << std::endl; - - out << "Attachment: " << std::endl; - mAttachment.print(out, int_Indent); - - out << "Thumbnail: " << std::endl; - mThumbnail.print(out, int_Indent); - - printRsItemEnd(out ,"RsGxsChannelPostItem", indent); - return out; -} -#endif - - -bool RsGxsChannelPostItem::fromChannelPost(RsGxsChannelPost &post, bool moveImage) -{ - clear(); - meta = post.mMeta; - mMsg = post.mMsg; - - if (moveImage) - { - mThumbnail.binData.bin_data = post.mThumbnail.mData; - mThumbnail.binData.bin_len = post.mThumbnail.mSize; - post.mThumbnail.shallowClear(); - } - else - { - mThumbnail.binData.setBinData(post.mThumbnail.mData, post.mThumbnail.mSize); - } - - std::list::iterator fit; - for(fit = post.mFiles.begin(); fit != post.mFiles.end(); ++fit) - { - RsTlvFileItem fi; - fi.name = fit->mName; - fi.filesize = fit->mSize; - fi.hash = fit->mHash; - mAttachment.items.push_back(fi); - } - return true; -} - - - -bool RsGxsChannelPostItem::toChannelPost(RsGxsChannelPost &post, bool moveImage) -{ - post.mMeta = meta; - post.mMsg = mMsg; - if (moveImage) - { - post.mThumbnail.take((uint8_t *) mThumbnail.binData.bin_data, mThumbnail.binData.bin_len); - // mThumbnail doesn't have a ShallowClear at the moment! - mThumbnail.binData.TlvShallowClear(); - } - else - { - post.mThumbnail.copy((uint8_t *) mThumbnail.binData.bin_data, mThumbnail.binData.bin_len); - } - - post.mCount = 0; - post.mSize = 0; - std::list::iterator fit; - for(fit = mAttachment.items.begin(); fit != mAttachment.items.end(); ++fit) - { - RsGxsFile fi; - fi.mName = RsDirUtil::getTopDir(fit->name); - fi.mSize = fit->filesize; - fi.mHash = fit->hash; - - post.mFiles.push_back(fi); - post.mCount++; - post.mSize += fi.mSize; - } - return true; -} - -void RsGxsChannelPostItem::clear() -{ - mMsg.clear(); - mAttachment.TlvClear(); - mThumbnail.TlvClear(); -} - -#ifdef TO_REMOVE - -uint32_t RsGxsChannelSerialiser::sizeGxsChannelPostItem(RsGxsChannelPostItem *item) -{ - uint32_t s = 8; // header - - s += GetTlvStringSize(item->mMsg); // mMsg. - s += item->mAttachment.TlvSize(); - s += item->mThumbnail.TlvSize(); - - return s; -} -#endif - -void RsGxsChannelPostItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) -{ - RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_MSG,mMsg,"mMsg") ; - RsTypeSerializer::serial_process(j,ctx,mAttachment,"mAttachment") ; - RsTypeSerializer::serial_process(j,ctx,mThumbnail,"mThumbnail") ; -} - -#ifdef TO_REMOVE -bool RsGxsChannelSerialiser::serialiseGxsChannelPostItem(RsGxsChannelPostItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelPostItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsChannelPostItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelPostItem() ERROR space too small" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsChannelPostItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->mMsg); - item->mAttachment.SetTlv(data, tlvsize, &offset); - item->mThumbnail.SetTlv(data, tlvsize, &offset); - - if(offset != tlvsize) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelPostItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSCHANNEL_DEBUG - if (!ok) - { - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelGroupItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsChannelPostItem* RsGxsChannelSerialiser::deserialiseGxsChannelPostItem(void *data, uint32_t *size) -{ - -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelPostItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_CHANNELS != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSCHANNEL_POST_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelPostItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelPostItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsChannelPostItem* item = new RsGxsChannelPostItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->mMsg); - item->mAttachment.GetTlv(data, rssize, &offset); - item->mThumbnail.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelPostItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSCHANNEL_DEBUG - std::cerr << "RsGxsChannelSerialiser::deserialiseGxsChannelPostItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ -#endif - From 559137d05b534070b0dfbaee42fedef26d5acc28 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 20:57:28 +0200 Subject: [PATCH 59/94] switched gxscircleitems to new serialization --- libretroshare/src/rsitems/rsgxsitems.h | 1 - .../src/serialiser/rsgxscircleitems.cc | 164 +++++++++++------- .../src/serialiser/rsgxscircleitems.h | 59 ++----- libretroshare/src/services/p3gxschannels.cc | 2 +- 4 files changed, 118 insertions(+), 108 deletions(-) diff --git a/libretroshare/src/rsitems/rsgxsitems.h b/libretroshare/src/rsitems/rsgxsitems.h index 026cbca08..3e7bd814c 100644 --- a/libretroshare/src/rsitems/rsgxsitems.h +++ b/libretroshare/src/rsitems/rsgxsitems.h @@ -34,7 +34,6 @@ std::ostream &operator<<(std::ostream &out, const RsGroupMetaData &meta); std::ostream &operator<<(std::ostream &out, const RsMsgMetaData &meta); - class RsGxsGrpItem : public RsItem { diff --git a/libretroshare/src/serialiser/rsgxscircleitems.cc b/libretroshare/src/serialiser/rsgxscircleitems.cc index c9cce891e..ae3dc6d69 100644 --- a/libretroshare/src/serialiser/rsgxscircleitems.cc +++ b/libretroshare/src/serialiser/rsgxscircleitems.cc @@ -26,11 +26,104 @@ #include #include "rsgxscircleitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" + +#include "serialization/rstypeserializer.h" //#define CIRCLE_DEBUG 1 +RsItem *RsGxsCircleSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const +{ + if(service != RS_SERVICE_GXS_TYPE_GXSCIRCLE) + return NULL ; + + switch(item_sub_id) + { + case RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM: return new RsGxsCircleGroupItem(); + case RS_PKT_SUBTYPE_GXSCIRCLE_MSG_ITEM: return new RsGxsCircleMsgItem(); + case RS_PKT_SUBTYPE_GXSCIRCLE_SUBSCRIPTION_REQUEST_ITEM: return new RsGxsCircleSubscriptionRequestItem(); + default: + return NULL ; + } +} + +void RsGxsCircleSubscriptionRequestItem::clear() +{ + time_stamp = 0 ; + time_out = 0 ; + subscription_type = SUBSCRIPTION_REQUEST_UNKNOWN; +} + +void RsGxsCircleMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,msg.stuff,"msg.stuff") ; +} + +void RsGxsCircleSubscriptionRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,time_stamp,"time_stamp") ; + RsTypeSerializer::serial_process(j,ctx,time_out ,"time_out") ; + RsTypeSerializer::serial_process (j,ctx,subscription_type ,"subscription_type") ; +} + +void RsGxsCircleGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,pgpIdSet,"pgpIdSet") ; + RsTypeSerializer::serial_process(j,ctx,gxsIdSet,"gxsIdSet") ; + RsTypeSerializer::serial_process(j,ctx,subCircleSet,"subCircleSet") ; +} + +void RsGxsCircleMsgItem::clear() +{ + msg.stuff.clear(); +} + +void RsGxsCircleGroupItem::clear() +{ + pgpIdSet.TlvClear(); + gxsIdSet.TlvClear(); + subCircleSet.TlvClear(); +} + +bool RsGxsCircleGroupItem::convertFrom(const RsGxsCircleGroup &group) +{ + clear(); + + meta = group.mMeta; + + // Enforce the local rules. + if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) + { + pgpIdSet.ids = group.mLocalFriends; + } + else + { + gxsIdSet.ids = group.mInvitedMembers; + } + + subCircleSet.ids = group.mSubCircles; + return true; +} + +bool RsGxsCircleGroupItem::convertTo(RsGxsCircleGroup &group) const +{ + group.mMeta = meta; + + // Enforce the local rules. + if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) + { + group.mLocalFriends = pgpIdSet.ids; + } + else + { + group.mInvitedMembers = gxsIdSet.ids; + } + + group.mSubCircles = subCircleSet.ids; + return true; +} + + +#ifdef TO_REMOVE uint32_t RsGxsCircleSerialiser::size(RsItem *item) { RsGxsCircleGroupItem* grp_item = NULL; @@ -115,14 +208,6 @@ RsItem* RsGxsCircleSerialiser::deserialise(void* data, uint32_t* size) /*****************************************************************************************/ /*****************************************************************************************/ /*****************************************************************************************/ - -void RsGxsCircleSubscriptionRequestItem::clear() -{ - time_stamp = 0 ; - time_out = 0 ; - subscription_type = SUBSCRIPTION_REQUEST_UNKNOWN; -} - std::ostream& RsGxsCircleSubscriptionRequestItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsCircleSubscriptionRequestItem", indent); @@ -135,51 +220,6 @@ std::ostream& RsGxsCircleSubscriptionRequestItem::print(std::ostream& out, uint1 return out; } -void RsGxsCircleGroupItem::clear() -{ - pgpIdSet.TlvClear(); - gxsIdSet.TlvClear(); - subCircleSet.TlvClear(); -} - -bool RsGxsCircleGroupItem::convertFrom(const RsGxsCircleGroup &group) -{ - clear(); - - meta = group.mMeta; - - // Enforce the local rules. - if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) - { - pgpIdSet.ids = group.mLocalFriends; - } - else - { - gxsIdSet.ids = group.mInvitedMembers; - } - - subCircleSet.ids = group.mSubCircles; - return true; -} - -bool RsGxsCircleGroupItem::convertTo(RsGxsCircleGroup &group) const -{ - group.mMeta = meta; - - // Enforce the local rules. - if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) - { - group.mLocalFriends = pgpIdSet.ids; - } - else - { - group.mInvitedMembers = gxsIdSet.ids; - } - - group.mSubCircles = subCircleSet.ids; - return true; -} - std::ostream& RsGxsCircleGroupItem::print(std::ostream& out, uint16_t indent) { @@ -275,7 +315,6 @@ bool RsGxsCircleSerialiser::serialiseGxsCircleSubscriptionRequestItem(RsGxsCircl return ok; } - bool RsGxsCircleSerialiser::serialiseGxsCircleGroupItem(RsGxsCircleGroupItem *item, void *data, uint32_t *size) { @@ -324,8 +363,7 @@ bool RsGxsCircleSerialiser::serialiseGxsCircleGroupItem(RsGxsCircleGroupItem *it #endif return ok; - } - +} RsGxsCircleSubscriptionRequestItem *RsGxsCircleSerialiser::deserialiseGxsCircleSubscriptionRequestItem(void *data, uint32_t *size) { @@ -463,13 +501,6 @@ RsGxsCircleGroupItem* RsGxsCircleSerialiser::deserialiseGxsCircleGroupItem(void /*****************************************************************************************/ /*****************************************************************************************/ /*****************************************************************************************/ - - -void RsGxsCircleMsgItem::clear() -{ - msg.stuff.clear(); -} - std::ostream& RsGxsCircleMsgItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsCircleMsgItem", indent); @@ -494,6 +525,7 @@ uint32_t RsGxsCircleSerialiser::sizeGxsCircleMsgItem(RsGxsCircleMsgItem *item) return s; } + bool RsGxsCircleSerialiser::serialiseGxsCircleMsgItem(RsGxsCircleMsgItem *item, void *data, uint32_t *size) { @@ -610,4 +642,4 @@ RsGxsCircleMsgItem* RsGxsCircleSerialiser::deserialiseGxsCircleMsgItem(void *dat /*****************************************************************************************/ /*****************************************************************************************/ /*****************************************************************************************/ - +#endif diff --git a/libretroshare/src/serialiser/rsgxscircleitems.h b/libretroshare/src/serialiser/rsgxscircleitems.h index ba28f2782..5734b34cd 100644 --- a/libretroshare/src/serialiser/rsgxscircleitems.h +++ b/libretroshare/src/serialiser/rsgxscircleitems.h @@ -52,18 +52,12 @@ class RsGxsCircleGroupItem : public RsGxsGrpItem public: - RsGxsCircleGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_GXSCIRCLE, - RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM) -#if 0 - pgpIdSet(GXSCIRCLE_PGPIDSET), - gxsIdSet(GXSCIRCLE_GXSIDSET), - subCircleSet(GXSCIRCLE_SUBCIRCLESET) -#endif - { return;} - virtual ~RsGxsCircleGroupItem() { return;} + RsGxsCircleGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_GXSCIRCLE, RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM) {} + virtual ~RsGxsCircleGroupItem() {} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); bool convertFrom(const RsGxsCircleGroup &group); bool convertTo(RsGxsCircleGroup &group) const; @@ -78,11 +72,12 @@ class RsGxsCircleMsgItem : public RsGxsMsgItem { public: - RsGxsCircleMsgItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_GXSCIRCLE, - RS_PKT_SUBTYPE_GXSCIRCLE_MSG_ITEM) {return; } - virtual ~RsGxsCircleMsgItem() { return;} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsCircleMsgItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_GXSCIRCLE, RS_PKT_SUBTYPE_GXSCIRCLE_MSG_ITEM) {} + virtual ~RsGxsCircleMsgItem() {} + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + RsGxsCircleMsg msg; }; @@ -94,7 +89,6 @@ public: virtual ~RsGxsCircleSubscriptionRequestItem() {} void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); enum { SUBSCRIPTION_REQUEST_UNKNOWN = 0x00, @@ -102,37 +96,22 @@ public: SUBSCRIPTION_REQUEST_UNSUBSCRIBE = 0x02 }; - time_t time_stamp ; - time_t time_out ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + uint32_t time_stamp ; + uint32_t time_out ; uint8_t subscription_type ; }; -class RsGxsCircleSerialiser : public RsSerialType +class RsGxsCircleSerialiser : public RsServiceSerializer { public: RsGxsCircleSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_GXSCIRCLE) - { return; } - virtual ~RsGxsCircleSerialiser() { return; } + :RsServiceSerializer(RS_SERVICE_GXS_TYPE_GXSCIRCLE) {} + virtual ~RsGxsCircleSerialiser() {} - uint32_t size(RsItem *item); - bool serialise (RsItem *item, void *data, uint32_t *size); - RsItem * deserialise(void *data, uint32_t *size); - - private: - - uint32_t sizeGxsCircleSubscriptionRequestItem(RsGxsCircleSubscriptionRequestItem *item); - bool serialiseGxsCircleSubscriptionRequestItem (RsGxsCircleSubscriptionRequestItem *item, void *data, uint32_t *size); - RsGxsCircleSubscriptionRequestItem * deserialiseGxsCircleSubscriptionRequestItem(void *data, uint32_t *size); - - uint32_t sizeGxsCircleGroupItem(RsGxsCircleGroupItem *item); - bool serialiseGxsCircleGroupItem (RsGxsCircleGroupItem *item, void *data, uint32_t *size); - RsGxsCircleGroupItem * deserialiseGxsCircleGroupItem(void *data, uint32_t *size); - - uint32_t sizeGxsCircleMsgItem(RsGxsCircleMsgItem *item); - bool serialiseGxsCircleMsgItem (RsGxsCircleMsgItem *item, void *data, uint32_t *size); - RsGxsCircleMsgItem * deserialiseGxsCircleMsgItem(void *data, uint32_t *size); + virtual RsItem *create_item(uint16_t service, uint8_t item_sub_id) const; }; #endif /* RS_GXSCIRCLE_ITEMS_H */ diff --git a/libretroshare/src/services/p3gxschannels.cc b/libretroshare/src/services/p3gxschannels.cc index 6410bd396..6805bb0ab 100644 --- a/libretroshare/src/services/p3gxschannels.cc +++ b/libretroshare/src/services/p3gxschannels.cc @@ -24,7 +24,7 @@ */ #include "services/p3gxschannels.h" -#include "serialiser/rsgxschannelitems.h" +#include "rsitems/rsgxschannelitems.h" #include "util/radix64.h" #include "util/rsmemory.h" From f50670f77376e93357c7a3a139e0ceed89d5a83e Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 26 Apr 2017 20:59:59 +0200 Subject: [PATCH 60/94] moved circle items to rsitems/ --- libretroshare/src/libretroshare.pro | 4 +- libretroshare/src/rsitems/rsgxscircleitems.cc | 124 ++++ .../rsgxscircleitems.h | 0 .../src/serialiser/rsgxscircleitems.cc | 645 ------------------ libretroshare/src/services/p3gxscircles.cc | 3 +- 5 files changed, 128 insertions(+), 648 deletions(-) create mode 100644 libretroshare/src/rsitems/rsgxscircleitems.cc rename libretroshare/src/{serialiser => rsitems}/rsgxscircleitems.h (100%) delete mode 100644 libretroshare/src/serialiser/rsgxscircleitems.cc diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index d13df8213..43a0eb6dd 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -794,11 +794,11 @@ SOURCES += services/p3idservice.cc \ # GxsCircles Service HEADERS += services/p3gxscircles.h \ - serialiser/rsgxscircleitems.h \ + rsitems/rsgxscircleitems.h \ retroshare/rsgxscircles.h \ SOURCES += services/p3gxscircles.cc \ - serialiser/rsgxscircleitems.cc \ + rsitems/rsgxscircleitems.cc \ # GxsForums Service HEADERS += retroshare/rsgxsforums.h \ diff --git a/libretroshare/src/rsitems/rsgxscircleitems.cc b/libretroshare/src/rsitems/rsgxscircleitems.cc new file mode 100644 index 000000000..a5937b5ab --- /dev/null +++ b/libretroshare/src/rsitems/rsgxscircleitems.cc @@ -0,0 +1,124 @@ +/* + * libretroshare/src/serialiser: rswikiitems.cc + * + * RetroShare C++ Interface. + * + * Copyright 2012-2012 by Robert Fernie + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2.1 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include "rsgxscircleitems.h" + +#include "serialization/rstypeserializer.h" + +//#define CIRCLE_DEBUG 1 + +RsItem *RsGxsCircleSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const +{ + if(service != RS_SERVICE_GXS_TYPE_GXSCIRCLE) + return NULL ; + + switch(item_sub_id) + { + case RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM: return new RsGxsCircleGroupItem(); + case RS_PKT_SUBTYPE_GXSCIRCLE_MSG_ITEM: return new RsGxsCircleMsgItem(); + case RS_PKT_SUBTYPE_GXSCIRCLE_SUBSCRIPTION_REQUEST_ITEM: return new RsGxsCircleSubscriptionRequestItem(); + default: + return NULL ; + } +} + +void RsGxsCircleSubscriptionRequestItem::clear() +{ + time_stamp = 0 ; + time_out = 0 ; + subscription_type = SUBSCRIPTION_REQUEST_UNKNOWN; +} + +void RsGxsCircleMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,msg.stuff,"msg.stuff") ; +} + +void RsGxsCircleSubscriptionRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,time_stamp,"time_stamp") ; + RsTypeSerializer::serial_process(j,ctx,time_out ,"time_out") ; + RsTypeSerializer::serial_process (j,ctx,subscription_type ,"subscription_type") ; +} + +void RsGxsCircleGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,pgpIdSet,"pgpIdSet") ; + RsTypeSerializer::serial_process(j,ctx,gxsIdSet,"gxsIdSet") ; + RsTypeSerializer::serial_process(j,ctx,subCircleSet,"subCircleSet") ; +} + +void RsGxsCircleMsgItem::clear() +{ + msg.stuff.clear(); +} + +void RsGxsCircleGroupItem::clear() +{ + pgpIdSet.TlvClear(); + gxsIdSet.TlvClear(); + subCircleSet.TlvClear(); +} + +bool RsGxsCircleGroupItem::convertFrom(const RsGxsCircleGroup &group) +{ + clear(); + + meta = group.mMeta; + + // Enforce the local rules. + if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) + { + pgpIdSet.ids = group.mLocalFriends; + } + else + { + gxsIdSet.ids = group.mInvitedMembers; + } + + subCircleSet.ids = group.mSubCircles; + return true; +} + +bool RsGxsCircleGroupItem::convertTo(RsGxsCircleGroup &group) const +{ + group.mMeta = meta; + + // Enforce the local rules. + if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) + { + group.mLocalFriends = pgpIdSet.ids; + } + else + { + group.mInvitedMembers = gxsIdSet.ids; + } + + group.mSubCircles = subCircleSet.ids; + return true; +} + diff --git a/libretroshare/src/serialiser/rsgxscircleitems.h b/libretroshare/src/rsitems/rsgxscircleitems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxscircleitems.h rename to libretroshare/src/rsitems/rsgxscircleitems.h diff --git a/libretroshare/src/serialiser/rsgxscircleitems.cc b/libretroshare/src/serialiser/rsgxscircleitems.cc deleted file mode 100644 index ae3dc6d69..000000000 --- a/libretroshare/src/serialiser/rsgxscircleitems.cc +++ /dev/null @@ -1,645 +0,0 @@ -/* - * libretroshare/src/serialiser: rswikiitems.cc - * - * RetroShare C++ Interface. - * - * Copyright 2012-2012 by Robert Fernie - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License Version 2.1 as published by the Free Software Foundation. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA. - * - * Please report all bugs and problems to "retroshare@lunamutt.com". - * - */ - -#include - -#include "rsgxscircleitems.h" - -#include "serialization/rstypeserializer.h" - -//#define CIRCLE_DEBUG 1 - -RsItem *RsGxsCircleSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const -{ - if(service != RS_SERVICE_GXS_TYPE_GXSCIRCLE) - return NULL ; - - switch(item_sub_id) - { - case RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM: return new RsGxsCircleGroupItem(); - case RS_PKT_SUBTYPE_GXSCIRCLE_MSG_ITEM: return new RsGxsCircleMsgItem(); - case RS_PKT_SUBTYPE_GXSCIRCLE_SUBSCRIPTION_REQUEST_ITEM: return new RsGxsCircleSubscriptionRequestItem(); - default: - return NULL ; - } -} - -void RsGxsCircleSubscriptionRequestItem::clear() -{ - time_stamp = 0 ; - time_out = 0 ; - subscription_type = SUBSCRIPTION_REQUEST_UNKNOWN; -} - -void RsGxsCircleMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) -{ - RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,msg.stuff,"msg.stuff") ; -} - -void RsGxsCircleSubscriptionRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) -{ - RsTypeSerializer::serial_process(j,ctx,time_stamp,"time_stamp") ; - RsTypeSerializer::serial_process(j,ctx,time_out ,"time_out") ; - RsTypeSerializer::serial_process (j,ctx,subscription_type ,"subscription_type") ; -} - -void RsGxsCircleGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) -{ - RsTypeSerializer::serial_process(j,ctx,pgpIdSet,"pgpIdSet") ; - RsTypeSerializer::serial_process(j,ctx,gxsIdSet,"gxsIdSet") ; - RsTypeSerializer::serial_process(j,ctx,subCircleSet,"subCircleSet") ; -} - -void RsGxsCircleMsgItem::clear() -{ - msg.stuff.clear(); -} - -void RsGxsCircleGroupItem::clear() -{ - pgpIdSet.TlvClear(); - gxsIdSet.TlvClear(); - subCircleSet.TlvClear(); -} - -bool RsGxsCircleGroupItem::convertFrom(const RsGxsCircleGroup &group) -{ - clear(); - - meta = group.mMeta; - - // Enforce the local rules. - if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) - { - pgpIdSet.ids = group.mLocalFriends; - } - else - { - gxsIdSet.ids = group.mInvitedMembers; - } - - subCircleSet.ids = group.mSubCircles; - return true; -} - -bool RsGxsCircleGroupItem::convertTo(RsGxsCircleGroup &group) const -{ - group.mMeta = meta; - - // Enforce the local rules. - if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) - { - group.mLocalFriends = pgpIdSet.ids; - } - else - { - group.mInvitedMembers = gxsIdSet.ids; - } - - group.mSubCircles = subCircleSet.ids; - return true; -} - - -#ifdef TO_REMOVE -uint32_t RsGxsCircleSerialiser::size(RsItem *item) -{ - RsGxsCircleGroupItem* grp_item = NULL; - RsGxsCircleMsgItem* snap_item = NULL; - RsGxsCircleSubscriptionRequestItem* subr_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return sizeGxsCircleGroupItem(grp_item); - } - else if((snap_item = dynamic_cast(item)) != NULL) - { - return sizeGxsCircleMsgItem(snap_item); - } - else if((subr_item = dynamic_cast(item)) != NULL) - { - return sizeGxsCircleSubscriptionRequestItem(subr_item); - } - else - return 0 ; -} - -bool RsGxsCircleSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ - RsGxsCircleGroupItem* grp_item = NULL; - RsGxsCircleMsgItem* snap_item = NULL; - RsGxsCircleSubscriptionRequestItem* subr_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsCircleGroupItem(grp_item, data, size); - } - else if((snap_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsCircleMsgItem(snap_item, data, size); - } - else if((subr_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsCircleSubscriptionRequestItem(subr_item, data, size); - } - return false; -} - -RsItem* RsGxsCircleSerialiser::deserialise(void* data, uint32_t* size) -{ - -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_GXS_TYPE_GXSCIRCLE != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM: - return deserialiseGxsCircleGroupItem(data, size); - break; - case RS_PKT_SUBTYPE_GXSCIRCLE_MSG_ITEM: - return deserialiseGxsCircleMsgItem(data, size); - break; - case RS_PKT_SUBTYPE_GXSCIRCLE_SUBSCRIPTION_REQUEST_ITEM: - return deserialiseGxsCircleSubscriptionRequestItem(data, size); - break; - default: -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialise(): unknown subtype"; - std::cerr << std::endl; -#endif - break; - } - return NULL; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ -std::ostream& RsGxsCircleSubscriptionRequestItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsCircleSubscriptionRequestItem", indent); - - printRsItemBase(out, "time stmp: ", indent); out << time_stamp ; - printRsItemBase(out, "time out : ", indent); out << time_out ; - printRsItemBase(out, "Subs type: ", indent); out << subscription_type ; - - printRsItemEnd(out ,"RsGxsCircleSubscriptionRequestItem", indent); - return out; -} - - -std::ostream& RsGxsCircleGroupItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsCircleGroupItem", indent); - uint16_t int_Indent = indent + 2; - - if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) - { - printRsItemBase(out, "Local Circle: PGP Ids:", indent); - pgpIdSet.print(out, int_Indent); - printRsItemBase(out, "GXS Ids (should be empty):", indent); - gxsIdSet.print(out, int_Indent); - } - else - { - printRsItemBase(out, "External Circle: GXS Ids", indent); - gxsIdSet.print(out, int_Indent); - printRsItemBase(out, "PGP Ids (should be empty):", indent); - pgpIdSet.print(out, int_Indent); - } - - subCircleSet.print(out, int_Indent); - printRsItemEnd(out ,"RsGxsCircleGroupItem", indent); - return out; -} - -uint32_t RsGxsCircleSerialiser::sizeGxsCircleSubscriptionRequestItem(RsGxsCircleSubscriptionRequestItem * /* item */) -{ - uint32_t s=8 ; // header - - s += 4 ; // time_stamp serialised as uint32_t; - s += 4 ; // time_out serialised as uint32_t; - s += 1 ; // subscription_type ; - - return s ; -} - -uint32_t RsGxsCircleSerialiser::sizeGxsCircleGroupItem(RsGxsCircleGroupItem *item) -{ - uint32_t s = 8; // header - - s += item->pgpIdSet.TlvSize(); - s += item->gxsIdSet.TlvSize(); - s += item->subCircleSet.TlvSize(); - - return s; -} - -bool RsGxsCircleSerialiser::serialiseGxsCircleSubscriptionRequestItem(RsGxsCircleSubscriptionRequestItem *item, void *data, uint32_t *size) -{ - -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleSubscriptionRequestItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsCircleSubscriptionRequestItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleSubscriptionRequestItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsCircleGroupItem */ - ok &= setRawUInt32(data,tlvsize,&offset,item->time_stamp) ; - ok &= setRawUInt32(data,tlvsize,&offset,item->time_out) ; - ok &= setRawUInt8(data,tlvsize,&offset,item->subscription_type) ; - - if(offset != tlvsize) - { - //#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleSubscriptionRequestItem() FAIL Size Error! " << std::endl; - //#endif - ok = false; - } - - //#ifdef CIRCLE_DEBUG - if (!ok) - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleSubscriptionRequestItem() NOK" << std::endl; - //#endif - - return ok; -} -bool RsGxsCircleSerialiser::serialiseGxsCircleGroupItem(RsGxsCircleGroupItem *item, void *data, uint32_t *size) -{ - -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleGroupItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsCircleGroupItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleGroupItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsCircleGroupItem */ - ok &= item->pgpIdSet.SetTlv(data, tlvsize, &offset); - ok &= item->gxsIdSet.SetTlv(data, tlvsize, &offset); - ok &= item->subCircleSet.SetTlv(data, tlvsize, &offset); - - if(offset != tlvsize) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleGroupItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef CIRCLE_DEBUG - if (!ok) - { - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleGroupItem() NOK" << std::endl; - } -#endif - - return ok; -} -RsGxsCircleSubscriptionRequestItem *RsGxsCircleSerialiser::deserialiseGxsCircleSubscriptionRequestItem(void *data, uint32_t *size) -{ - -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleSubscriptionRequestItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_GXSCIRCLE != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSCIRCLE_SUBSCRIPTION_REQUEST_ITEM != getRsItemSubType(rstype))) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleSubscriptionRequestItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleSubscriptionRequestItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsCircleSubscriptionRequestItem* item = new RsGxsCircleSubscriptionRequestItem(); - /* skip the header */ - offset += 8; - - uint32_t tmp ; - ok &= getRawUInt32(data,rssize,&offset,&tmp) ; item->time_stamp = tmp ; - ok &= getRawUInt32(data,rssize,&offset,&tmp) ; item->time_out = tmp ; - ok &= getRawUInt8(data,rssize,&offset,&item->subscription_type) ; - - if (offset != rssize) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleSubscriptionRequestItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleSubscriptionRequestItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} -RsGxsCircleGroupItem* RsGxsCircleSerialiser::deserialiseGxsCircleGroupItem(void *data, uint32_t *size) -{ - -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleGroupItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_GXSCIRCLE != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM != getRsItemSubType(rstype))) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleGroupItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleGroupItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsCircleGroupItem* item = new RsGxsCircleGroupItem(); - /* skip the header */ - offset += 8; - - ok &= item->pgpIdSet.GetTlv(data, rssize, &offset); - ok &= item->gxsIdSet.GetTlv(data, rssize, &offset); - ok &= item->subCircleSet.GetTlv(data, rssize, &offset); - - if (offset != rssize) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleGroupItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleGroupItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ -std::ostream& RsGxsCircleMsgItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsCircleMsgItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Stuff: " << msg.stuff << std::endl; - - printRsItemEnd(out ,"RsGxsCircleMsgItem", indent); - return out; -} - - -uint32_t RsGxsCircleSerialiser::sizeGxsCircleMsgItem(RsGxsCircleMsgItem *item) -{ - - const RsGxsCircleMsg &msg = item->msg; - uint32_t s = 8; // header - - s += GetTlvStringSize(msg.stuff); - - return s; -} - - -bool RsGxsCircleSerialiser::serialiseGxsCircleMsgItem(RsGxsCircleMsgItem *item, void *data, uint32_t *size) -{ - -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleMsgItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsCircleMsgItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleMsgItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsCircleMsgItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->msg.stuff); - - if(offset != tlvsize) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleMsgItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef CIRCLE_DEBUG - if (!ok) - { - std::cerr << "RsGxsCircleSerialiser::serialiseGxsCircleMsgItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsCircleMsgItem* RsGxsCircleSerialiser::deserialiseGxsCircleMsgItem(void *data, uint32_t *size) -{ - -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleMsgItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_GXSCIRCLE != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSCIRCLE_MSG_ITEM != getRsItemSubType(rstype))) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleMsgItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleMsgItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsCircleMsgItem* item = new RsGxsCircleMsgItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->msg.stuff); - - if (offset != rssize) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleMsgItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef CIRCLE_DEBUG - std::cerr << "RsGxsCircleSerialiser::deserialiseGxsCircleMsgItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ -#endif diff --git a/libretroshare/src/services/p3gxscircles.cc b/libretroshare/src/services/p3gxscircles.cc index cf731fcd8..0daa3d24e 100644 --- a/libretroshare/src/services/p3gxscircles.cc +++ b/libretroshare/src/services/p3gxscircles.cc @@ -23,8 +23,9 @@ * */ +#include "rsitems/rsgxscircleitems.h" + #include "services/p3gxscircles.h" -#include "serialiser/rsgxscircleitems.h" #include "retroshare/rsgxsflags.h" #include "util/rsrandom.h" #include "util/rsdir.h" From 449a4209d9b97b37fae4e3c5f7cedb432c2f5b0e Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 11:56:56 +0200 Subject: [PATCH 61/94] dwitched gxsforum items to new serialization --- libretroshare/src/rsitems/rsgxsitems.h | 1 - .../src/serialiser/rsgxsforumitems.cc | 366 +----------------- .../src/serialiser/rsgxsforumitems.h | 48 +-- 3 files changed, 32 insertions(+), 383 deletions(-) diff --git a/libretroshare/src/rsitems/rsgxsitems.h b/libretroshare/src/rsitems/rsgxsitems.h index 3e7bd814c..fa461a0e8 100644 --- a/libretroshare/src/rsitems/rsgxsitems.h +++ b/libretroshare/src/rsitems/rsgxsitems.h @@ -43,7 +43,6 @@ public: : RsItem(RS_PKT_VERSION_SERVICE, service, subtype) { return; } virtual ~RsGxsGrpItem(){} - RsGroupMetaData meta; }; diff --git a/libretroshare/src/serialiser/rsgxsforumitems.cc b/libretroshare/src/serialiser/rsgxsforumitems.cc index 731584b38..462f4fcf6 100644 --- a/libretroshare/src/serialiser/rsgxsforumitems.cc +++ b/libretroshare/src/serialiser/rsgxsforumitems.cc @@ -26,376 +26,42 @@ #include #include "rsgxsforumitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" + +#include "serialization/rstypeserializer.h" //#define GXSFORUM_DEBUG 1 -uint32_t RsGxsForumSerialiser::size(RsItem *item) +RsItem *RsGxsForumSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const { - RsGxsForumGroupItem* grp_item = NULL; - RsGxsForumMsgItem* op_item = NULL; + if(service_id != RS_SERVICE_GXS_TYPE_FORUMS) + return NULL ; - if((grp_item = dynamic_cast(item)) != NULL) - { - return sizeGxsForumGroupItem(grp_item); - } - else if((op_item = dynamic_cast(item)) != NULL) - { - return sizeGxsForumMsgItem(op_item); - } - std::cerr << "RsGxsForumSerialiser::size() ERROR invalid item" << std::endl; - return 0; + switch(item_subtype) + { + case RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM: return new RsGxsForumGroupItem(); + case RS_PKT_SUBTYPE_GXSFORUM_MESSAGE_ITEM: return new RsGxsForumMsgItem(); + default: + return NULL ; + } } - -bool RsGxsForumSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ - RsGxsForumGroupItem* grp_item = NULL; - RsGxsForumMsgItem* op_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsForumGroupItem(grp_item, data, size); - } - else if((op_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsForumMsgItem(op_item, data, size); - } - std::cerr << "RsGxsForumSerialiser::serialise() ERROR invalid item" << std::endl; - return false; -} - -RsItem* RsGxsForumSerialiser::deserialise(void* data, uint32_t* size) -{ - -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_FORUMS != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM: - return deserialiseGxsForumGroupItem(data, size); - break; - case RS_PKT_SUBTYPE_GXSFORUM_MESSAGE_ITEM: - return deserialiseGxsForumMsgItem(data, size); - break; - default: -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialise(): unknown subtype"; - std::cerr << std::endl; -#endif - break; - } - return NULL; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - void RsGxsForumGroupItem::clear() { mGroup.mDescription.clear(); } -std::ostream& RsGxsForumGroupItem::print(std::ostream& out, uint16_t indent) +void RsGxsForumGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - printRsItemBase(out, "RsGxsForumGroupItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Description: " << mGroup.mDescription << std::endl; - - printRsItemEnd(out ,"RsGxsForumGroupItem", indent); - return out; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR,mGroup.mDescription,"mGroup.Description"); } - - -uint32_t RsGxsForumSerialiser::sizeGxsForumGroupItem(RsGxsForumGroupItem *item) -{ - - const RsGxsForumGroup& group = item->mGroup; - uint32_t s = 8; // header - - s += GetTlvStringSize(group.mDescription); - - return s; -} - -bool RsGxsForumSerialiser::serialiseGxsForumGroupItem(RsGxsForumGroupItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::serialiseGxsForumGroupItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsForumGroupItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::serialiseGxsForumGroupItem() Size too small" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsForumGroupItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DESCR, item->mGroup.mDescription); - - if(offset != tlvsize) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::serialiseGxsForumGroupItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSFORUM_DEBUG - if (!ok) - { - std::cerr << "RsGxsForumSerialiser::serialiseGxsForumGroupItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsForumGroupItem* RsGxsForumSerialiser::deserialiseGxsForumGroupItem(void *data, uint32_t *size) -{ - -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumGroupItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_FORUMS != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumGroupItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumGroupItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsForumGroupItem* item = new RsGxsForumGroupItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DESCR, item->mGroup.mDescription); - - if (offset != rssize) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumGroupItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumGroupItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - void RsGxsForumMsgItem::clear() { mMsg.mMsg.clear(); } -std::ostream& RsGxsForumMsgItem::print(std::ostream& out, uint16_t indent) +void RsGxsForumMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - printRsItemBase(out, "RsGxsForumMsgItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Msg: " << mMsg.mMsg << std::endl; - - printRsItemEnd(out ,"RsGxsForumMsgItem", indent); - return out; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,mMsg.mMsg,"mGroup.Description"); } -uint32_t RsGxsForumSerialiser::sizeGxsForumMsgItem(RsGxsForumMsgItem *item) -{ - - const RsGxsForumMsg& msg = item->mMsg; - uint32_t s = 8; // header - - s += GetTlvStringSize(msg.mMsg); // mMsg. - - return s; -} - -bool RsGxsForumSerialiser::serialiseGxsForumMsgItem(RsGxsForumMsgItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::serialiseGxsForumMsgItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsForumMsgItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::serialiseGxsForumMsgItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsForumMsgItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->mMsg.mMsg); - - if(offset != tlvsize) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::serialiseGxsForumMsgItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSFORUM_DEBUG - if (!ok) - { - std::cerr << "RsGxsForumSerialiser::serialiseGxsForumGroupItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsForumMsgItem* RsGxsForumSerialiser::deserialiseGxsForumMsgItem(void *data, uint32_t *size) -{ - -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumMsgItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_FORUMS != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSFORUM_MESSAGE_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumMsgItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumMsgItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsForumMsgItem* item = new RsGxsForumMsgItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->mMsg.mMsg); - - if (offset != rssize) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumMsgItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSFORUM_DEBUG - std::cerr << "RsGxsForumSerialiser::deserialiseGxsForumMsgItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ diff --git a/libretroshare/src/serialiser/rsgxsforumitems.h b/libretroshare/src/serialiser/rsgxsforumitems.h index 22fae7e63..8e8d2bc24 100644 --- a/libretroshare/src/serialiser/rsgxsforumitems.h +++ b/libretroshare/src/serialiser/rsgxsforumitems.h @@ -31,9 +31,11 @@ #include "rsitems/rsserviceids.h" #include "rsitems/rsgxsitems.h" +#include "serialization/rsserializer.h" + #include "retroshare/rsgxsforums.h" -const uint8_t RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM = 0x02; +const uint8_t RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM = 0x02; const uint8_t RS_PKT_SUBTYPE_GXSFORUM_MESSAGE_ITEM = 0x03; class RsGxsForumGroupItem : public RsGxsGrpItem @@ -41,13 +43,11 @@ class RsGxsForumGroupItem : public RsGxsGrpItem public: - RsGxsForumGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_FORUMS, - RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM) { return;} - virtual ~RsGxsForumGroupItem() { return;} - - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsForumGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_FORUMS, RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM) {} + virtual ~RsGxsForumGroupItem() {} + void clear(); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsGxsForumGroup mGroup; }; @@ -56,38 +56,22 @@ class RsGxsForumMsgItem : public RsGxsMsgItem { public: - RsGxsForumMsgItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_FORUMS, - RS_PKT_SUBTYPE_GXSFORUM_MESSAGE_ITEM) {return; } - virtual ~RsGxsForumMsgItem() { return;} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsForumMsgItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_FORUMS, RS_PKT_SUBTYPE_GXSFORUM_MESSAGE_ITEM) {} + virtual ~RsGxsForumMsgItem() {} + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsGxsForumMsg mMsg; }; -class RsGxsForumSerialiser : public RsSerialType +class RsGxsForumSerialiser : public RsServiceSerializer { public: + RsGxsForumSerialiser() :RsServiceSerializer(RS_SERVICE_GXS_TYPE_FORUMS) {} + virtual ~RsGxsForumSerialiser() {} - RsGxsForumSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_FORUMS) - { return; } - virtual ~RsGxsForumSerialiser() { return; } - - uint32_t size(RsItem *item); - bool serialise (RsItem *item, void *data, uint32_t *size); - RsItem * deserialise(void *data, uint32_t *size); - - private: - - uint32_t sizeGxsForumGroupItem(RsGxsForumGroupItem *item); - bool serialiseGxsForumGroupItem (RsGxsForumGroupItem *item, void *data, uint32_t *size); - RsGxsForumGroupItem * deserialiseGxsForumGroupItem(void *data, uint32_t *size); - - uint32_t sizeGxsForumMsgItem(RsGxsForumMsgItem *item); - bool serialiseGxsForumMsgItem (RsGxsForumMsgItem *item, void *data, uint32_t *size); - RsGxsForumMsgItem * deserialiseGxsForumMsgItem(void *data, uint32_t *size); - + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; }; #endif /* RS_GXS_FORUM_ITEMS_H */ From f6e59f7dee865be575020792cd4d464b168e73c5 Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 11:59:18 +0200 Subject: [PATCH 62/94] moved gxsforumitems to rsitems/ --- libretroshare/src/libretroshare.pro | 4 ++-- libretroshare/src/{serialiser => rsitems}/rsgxsforumitems.cc | 0 libretroshare/src/{serialiser => rsitems}/rsgxsforumitems.h | 0 libretroshare/src/services/p3gxsforums.cc | 2 +- 4 files changed, 3 insertions(+), 3 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsgxsforumitems.cc (100%) rename libretroshare/src/{serialiser => rsitems}/rsgxsforumitems.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 43a0eb6dd..4d2e75c7c 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -803,10 +803,10 @@ SOURCES += services/p3gxscircles.cc \ # GxsForums Service HEADERS += retroshare/rsgxsforums.h \ services/p3gxsforums.h \ - serialiser/rsgxsforumitems.h + rsitems/rsgxsforumitems.h SOURCES += services/p3gxsforums.cc \ - serialiser/rsgxsforumitems.cc \ + rsitems/rsgxsforumitems.cc \ # GxsChannels Service HEADERS += retroshare/rsgxschannels.h \ diff --git a/libretroshare/src/serialiser/rsgxsforumitems.cc b/libretroshare/src/rsitems/rsgxsforumitems.cc similarity index 100% rename from libretroshare/src/serialiser/rsgxsforumitems.cc rename to libretroshare/src/rsitems/rsgxsforumitems.cc diff --git a/libretroshare/src/serialiser/rsgxsforumitems.h b/libretroshare/src/rsitems/rsgxsforumitems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxsforumitems.h rename to libretroshare/src/rsitems/rsgxsforumitems.h diff --git a/libretroshare/src/services/p3gxsforums.cc b/libretroshare/src/services/p3gxsforums.cc index 29c7ed6c7..72ad9ad46 100644 --- a/libretroshare/src/services/p3gxsforums.cc +++ b/libretroshare/src/services/p3gxsforums.cc @@ -24,7 +24,7 @@ */ #include "services/p3gxsforums.h" -#include "serialiser/rsgxsforumitems.h" +#include "rsitems/rsgxsforumitems.h" #include From 3c20a85335d88c2351175e4dafbf68db83b1dd9d Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 14:16:57 +0200 Subject: [PATCH 63/94] switched RsNxsItems to new serialization --- libretroshare/src/gxs/rsgxsnetservice.cc | 6 +- libretroshare/src/serialiser/rsnxsitems.cc | 283 +++++++++++++-------- libretroshare/src/serialiser/rsnxsitems.h | 169 ++++-------- 3 files changed, 223 insertions(+), 235 deletions(-) diff --git a/libretroshare/src/gxs/rsgxsnetservice.cc b/libretroshare/src/gxs/rsgxsnetservice.cc index 259d01135..1811f2658 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.cc +++ b/libretroshare/src/gxs/rsgxsnetservice.cc @@ -3500,10 +3500,10 @@ bool RsGxsNetService::encryptSingleNxsItem(RsNxsItem *item, const RsGxsCircleId& #ifdef NXS_NET_DEBUG_7 GXSNETDEBUG_P_ (item->PeerId()) << " Encrypting..." << std::endl; #endif - uint32_t size = item->serial_size() ; + uint32_t size = RsNxsSerialiser(mServType).size(item) ; RsTemporaryMemory tempmem( size ) ; - if(!item->serialise(tempmem,size)) + if(!RsNxsSerialiser(mServType).serialise(item,tempmem,&size)) { std::cerr << " (EE) Cannot serialise item. Something went wrong." << std::endl; status = RS_NXS_ITEM_ENCRYPTION_STATUS_SERIALISATION_ERROR ; @@ -3530,7 +3530,7 @@ bool RsGxsNetService::encryptSingleNxsItem(RsNxsItem *item, const RsGxsCircleId& enc_item->transactionNumber = item->transactionNumber ; enc_item->PeerId(item->PeerId()) ; - encrypted_item = enc_item ; + encrypted_item = enc_item ; #ifdef NXS_NET_DEBUG_7 GXSNETDEBUG_P_(item->PeerId()) << " encrypted item of size " << encrypted_len << std::endl; #endif diff --git a/libretroshare/src/serialiser/rsnxsitems.cc b/libretroshare/src/serialiser/rsnxsitems.cc index d17002ca9..bfea43843 100644 --- a/libretroshare/src/serialiser/rsnxsitems.cc +++ b/libretroshare/src/serialiser/rsnxsitems.cc @@ -1,8 +1,9 @@ #include "rsnxsitems.h" -#include "rsbaseserial.h" #include "util/rsprint.h" #include +#include "serialization/rstypeserializer.h" + /*** * #define RSSERIAL_DEBUG 1 ***/ @@ -37,47 +38,181 @@ const uint16_t RsNxsTransacItem::FLAG_TYPE_GRPS = 0x1000; const uint16_t RsNxsTransacItem::FLAG_TYPE_MSGS = 0x2000; const uint16_t RsNxsTransacItem::FLAG_TYPE_ENCRYPTED_DATA = 0x4000; -RsItem* RsNxsSerialiser::deserialise(void *data, uint32_t *size) +RsItem *RsNxsSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); + if(service_id != SERVICE_TYPE) + return NULL ; - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (SERVICE_TYPE != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_NXS_SYNC_GRP_REQ_ITEM: return deserialNxsSyncGrpReqItem(data, size); - case RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM: return deserialNxsSyncGrpItem(data, size); - case RS_PKT_SUBTYPE_NXS_SYNC_MSG_REQ_ITEM: return deserialNxsSyncMsgReqItem(data, size); - case RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM: return deserialNxsSyncMsgItem(data, size); - case RS_PKT_SUBTYPE_NXS_GRP_ITEM: return deserialNxsGrpItem(data, size); - case RS_PKT_SUBTYPE_NXS_MSG_ITEM: return deserialNxsMsgItem(data, size); - case RS_PKT_SUBTYPE_NXS_TRANSAC_ITEM: return deserialNxsTransacItem(data, size); - case RS_PKT_SUBTYPE_NXS_GRP_PUBLISH_KEY_ITEM:return deserialNxsGroupPublishKeyItem(data, size); - case RS_PKT_SUBTYPE_NXS_SESSION_KEY_ITEM: return deserialNxsSessionKeyItem(data, size); - case RS_PKT_SUBTYPE_NXS_ENCRYPTED_DATA_ITEM: return deserialNxsEncryptedDataItem(data, size); - case RS_PKT_SUBTYPE_NXS_SYNC_GRP_STATS_ITEM: return deserialNxsSyncGrpStatsItem(data, size); + switch(item_subtype) + { + case RS_PKT_SUBTYPE_NXS_SYNC_GRP_REQ_ITEM: return new RsNxsSyncGrpReqItem(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM: return new RsNxsSyncGrpItem(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_SYNC_MSG_REQ_ITEM: return new RsNxsSyncMsgReqItem(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM: return new RsNxsSyncMsgItem(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_GRP_ITEM: return new RsNxsGrp(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_MSG_ITEM: return new RsNxsMsg(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_TRANSAC_ITEM: return new RsNxsTransacItem(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_GRP_PUBLISH_KEY_ITEM:return new RsNxsGroupPublishKeyItem(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_ENCRYPTED_DATA_ITEM: return new RsNxsEncryptedDataItem(SERVICE_TYPE) ; + case RS_PKT_SUBTYPE_NXS_SYNC_GRP_STATS_ITEM: return new RsNxsSyncGrpStatsItem(SERVICE_TYPE) ; default: - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialise() : data has no type" - << std::endl; -#endif return NULL; - - } - } + } } +void RsNxsSyncMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,transactionNumber,"transactionNumber") ; + RsTypeSerializer::serial_process (j,ctx,flag ,"flag") ; + RsTypeSerializer::serial_process (j,ctx,grpId ,"grpId") ; + RsTypeSerializer::serial_process (j,ctx,msgId ,"msgId") ; + RsTypeSerializer::serial_process (j,ctx,authorId ,"authorId") ; +} +void RsNxsMsg::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,transactionNumber,"transactionNumber") ; + RsTypeSerializer::serial_process (j,ctx,pos ,"pos") ; + RsTypeSerializer::serial_process (j,ctx,msgId ,"msgId") ; + RsTypeSerializer::serial_process (j,ctx,grpId ,"grpId") ; + RsTypeSerializer::serial_process(j,ctx,msg ,"msg") ; + RsTypeSerializer::serial_process(j,ctx,meta ,"meta") ; +} +void RsNxsGrp::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,transactionNumber,"transactionNumber") ; + RsTypeSerializer::serial_process (j,ctx,pos ,"pos") ; + RsTypeSerializer::serial_process (j,ctx,grpId ,"grpId") ; + RsTypeSerializer::serial_process(j,ctx,grp ,"grp") ; + RsTypeSerializer::serial_process(j,ctx,meta ,"meta") ; +} + +void RsNxsSyncGrpStatsItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,request_type ,"request_type") ; + RsTypeSerializer::serial_process (j,ctx,grpId ,"grpId") ; + RsTypeSerializer::serial_process (j,ctx,number_of_posts,"number_of_posts") ; + RsTypeSerializer::serial_process (j,ctx,last_post_TS ,"last_post_TS") ; +} + +void RsNxsSyncGrpReqItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,transactionNumber,"transactionNumber") ; + RsTypeSerializer::serial_process (j,ctx,flag ,"flag") ; + RsTypeSerializer::serial_process(j,ctx,createdSince ,"createdSince") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_HASH_SHA1,syncHash,"syncHash") ; + RsTypeSerializer::serial_process(j,ctx,updateTS ,"updateTS") ; +} + +void RsNxsTransacItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,transactionNumber,"transactionNumber") ; + RsTypeSerializer::serial_process(j,ctx,transactFlag ,"transactFlag") ; + RsTypeSerializer::serial_process(j,ctx,nItems ,"nItems") ; + RsTypeSerializer::serial_process(j,ctx,updateTS ,"updateTS") ; +} +void RsNxsSyncGrpItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,transactionNumber,"transactionNumber") ; + RsTypeSerializer::serial_process (j,ctx,flag ,"flag") ; + RsTypeSerializer::serial_process (j,ctx,grpId ,"grpId") ; + RsTypeSerializer::serial_process(j,ctx,publishTs ,"publishTs") ; + RsTypeSerializer::serial_process (j,ctx,authorId ,"authorId") ; +} +void RsNxsSyncMsgReqItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,transactionNumber,"transactionNumber") ; + RsTypeSerializer::serial_process (j,ctx,flag ,"flag") ; + RsTypeSerializer::serial_process(j,ctx,createdSinceTS ,"createdSinceTS") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_HASH_SHA1,syncHash,"syncHash") ; + RsTypeSerializer::serial_process (j,ctx,grpId ,"grpId") ; + RsTypeSerializer::serial_process(j,ctx,updateTS ,"updateTS") ; +} +void RsNxsGroupPublishKeyItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,grpId ,"grpId") ; + RsTypeSerializer::serial_process(j,ctx,private_key ,"private_key") ; +} +void RsNxsEncryptedDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,transactionNumber,"transactionNumber") ; + RsTypeSerializer::serial_process(j,ctx,encrypted_data, "encrypted_data") ; +} + +int RsNxsGrp::refcount = 0; +/** print and clear functions **/ +int RsNxsMsg::refcount = 0; +void RsNxsMsg::clear() +{ + + msg.TlvClear(); + meta.TlvClear(); +} + +void RsNxsGrp::clear() +{ + grpId.clear(); + grp.TlvClear(); + meta.TlvClear(); +} + +void RsNxsSyncGrpReqItem::clear() +{ + flag = 0; + createdSince = 0; + syncHash.clear(); + updateTS = 0; +} +void RsNxsGroupPublishKeyItem::clear() +{ + private_key.TlvClear(); +} +void RsNxsSyncMsgReqItem::clear() +{ + grpId.clear(); + flag = 0; + createdSinceTS = 0; + syncHash.clear(); + updateTS = 0; +} +void RsNxsSyncGrpItem::clear() +{ + flag = 0; + publishTs = 0; + grpId.clear(); + authorId.clear(); +} + +void RsNxsSyncMsgItem::clear() +{ + flag = 0; + msgId.clear(); + grpId.clear(); + authorId.clear(); +} + +void RsNxsTransacItem::clear(){ + transactFlag = 0; + nItems = 0; + updateTS = 0; + timestamp = 0; + transactionNumber = 0; +} +void RsNxsEncryptedDataItem::clear(){ + encrypted_data.TlvClear() ; +} + +#ifdef SUSPENDED_CODE_27042017 +void RsNxsSessionKeyItem::clear() +{ + for(std::map::iterator it(encrypted_session_keys.begin());it!=encrypted_session_keys.end();++it) + it->second.TlvClear() ; + + encrypted_session_keys.clear() ; +} +#endif + +#ifdef TO_REMOVE uint32_t RsNxsSerialiser::size(RsItem *item) { @@ -165,7 +300,6 @@ bool RsNxsSyncMsgItem::serialise(void *data, uint32_t& size) const return ok; } - bool RsNxsMsg::serialise(void *data, uint32_t& size) const { uint32_t tlvsize,offset=0; @@ -231,7 +365,6 @@ bool RsNxsGrp::serialise(void *data, uint32_t& size) const return ok; } - bool RsNxsSyncGrpStatsItem::serialise(void *data, uint32_t& size) const { uint32_t tlvsize,offset=0; @@ -265,7 +398,6 @@ bool RsNxsSyncGrpStatsItem::serialise(void *data, uint32_t& size) const return ok; } - bool RsNxsSyncGrpReqItem::serialise(void *data, uint32_t& size) const { uint32_t tlvsize,offset=0; @@ -297,7 +429,6 @@ bool RsNxsSyncGrpReqItem::serialise(void *data, uint32_t& size) const return ok; } - bool RsNxsTransacItem::serialise(void *data, uint32_t& size) const { uint32_t tlvsize,offset=0; @@ -361,6 +492,7 @@ bool RsNxsSyncGrpItem::serialise(void *data, uint32_t& size) const return ok; } + bool RsNxsSyncMsgReqItem::serialise(void *data, uint32_t& size) const { uint32_t tlvsize,offset=0; @@ -1065,78 +1197,6 @@ uint32_t RsNxsSessionKeyItem::serial_size() const } - - -int RsNxsGrp::refcount = 0; -/** print and clear functions **/ -int RsNxsMsg::refcount = 0; -void RsNxsMsg::clear() -{ - - msg.TlvClear(); - meta.TlvClear(); -} - -void RsNxsGrp::clear() -{ - grpId.clear(); - grp.TlvClear(); - meta.TlvClear(); -} - -void RsNxsSyncGrpReqItem::clear() -{ - flag = 0; - createdSince = 0; - syncHash.clear(); - updateTS = 0; -} -void RsNxsGroupPublishKeyItem::clear() -{ - private_key.TlvClear(); -} -void RsNxsSyncMsgReqItem::clear() -{ - grpId.clear(); - flag = 0; - createdSinceTS = 0; - syncHash.clear(); - updateTS = 0; -} -void RsNxsSyncGrpItem::clear() -{ - flag = 0; - publishTs = 0; - grpId.clear(); - authorId.clear(); -} - -void RsNxsSyncMsgItem::clear() -{ - flag = 0; - msgId.clear(); - grpId.clear(); - authorId.clear(); -} - -void RsNxsTransacItem::clear(){ - transactFlag = 0; - nItems = 0; - updateTS = 0; - timestamp = 0; - transactionNumber = 0; -} -void RsNxsEncryptedDataItem::clear(){ - encrypted_data.TlvClear() ; -} -void RsNxsSessionKeyItem::clear() -{ - for(std::map::iterator it(encrypted_session_keys.begin());it!=encrypted_session_keys.end();++it) - it->second.TlvClear() ; - - encrypted_session_keys.clear() ; -} - std::ostream& RsNxsSyncGrpReqItem::print(std::ostream &out, uint16_t indent) { @@ -1347,3 +1407,4 @@ std::ostream& RsNxsEncryptedDataItem::print(std::ostream &out, uint16_t indent) printRsItemEnd(out ,"RsNxsSessionKeyItem", indent); return out; } +#endif diff --git a/libretroshare/src/serialiser/rsnxsitems.h b/libretroshare/src/serialiser/rsnxsitems.h index 2f4886507..10eb1d835 100644 --- a/libretroshare/src/serialiser/rsnxsitems.h +++ b/libretroshare/src/serialiser/rsnxsitems.h @@ -72,20 +72,13 @@ class RsNxsItem : public RsItem { public: - RsNxsItem(uint16_t servtype, uint8_t subtype) - : RsItem(RS_PKT_VERSION_SERVICE, servtype, subtype), transactionNumber(0) + RsNxsItem(uint16_t servtype, uint8_t subtype) : RsItem(RS_PKT_VERSION_SERVICE, servtype, subtype), transactionNumber(0) { setPriorityLevel(QOS_PRIORITY_RS_GXS_NET); return; } virtual ~RsNxsItem(){} - - virtual bool serialise(void *data,uint32_t& size) const = 0 ; - virtual uint32_t serial_size() const = 0 ; virtual void clear() = 0; - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0) = 0; - - bool serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const; uint32_t transactionNumber; // set to zero if this is not a transaction item }; @@ -103,14 +96,11 @@ public: static const uint8_t FLAG_USE_SYNC_HASH; static const uint8_t FLAG_ONLY_CURRENT; // only send most current version of grps / ignores sync hash - RsNxsSyncGrpReqItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_REQ_ITEM) { clear(); return;} - + RsNxsSyncGrpReqItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_REQ_ITEM) { clear();} virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const ; - + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + uint8_t flag; // advises whether to use sync hash uint32_t createdSince; // how far back to sync data uint32_t updateTS; // time of last group update @@ -127,14 +117,12 @@ public: RsNxsSyncGrpStatsItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_STATS_ITEM) {} virtual void clear() {} - virtual std::ostream &print(std::ostream &out, uint16_t indent); - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const ; - static const uint8_t GROUP_INFO_TYPE_REQUEST = 0x01; static const uint8_t GROUP_INFO_TYPE_RESPONSE = 0x02; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + uint32_t request_type; // used to determine the type of request RsGxsGroupId grpId; // id of the group uint32_t number_of_posts; // number of posts in that group @@ -149,14 +137,12 @@ public: class RsNxsGroupPublishKeyItem : public RsNxsItem { public: - RsNxsGroupPublishKeyItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP_PUBLISH_KEY_ITEM) { clear(); return;} + RsNxsGroupPublishKeyItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP_PUBLISH_KEY_ITEM) { clear(); } virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + RsGxsGroupId grpId ; RsTlvPrivateRSAKey private_key ; }; @@ -194,14 +180,12 @@ public: static const uint16_t FLAG_TYPE_MSGS; static const uint16_t FLAG_TYPE_ENCRYPTED_DATA; - RsNxsTransacItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_TRANSAC_ITEM) { clear(); return; } - virtual ~RsNxsTransacItem() { return ; } + RsNxsTransacItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_TRANSAC_ITEM) { clear(); } + virtual ~RsNxsTransacItem() {} - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const ; - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint16_t transactFlag; uint32_t nItems; @@ -224,18 +208,14 @@ public: static const uint8_t FLAG_RESPONSE; static const uint8_t FLAG_USE_SYNC_HASH; - RsNxsSyncGrpItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM) { clear(); return ; } - virtual ~RsNxsSyncGrpItem() { return; } + RsNxsSyncGrpItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM) { clear();} + virtual ~RsNxsSyncGrpItem() {} - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint8_t flag; // request or response - uint32_t publishTs; // to compare to Ts of receiving peer's grp of same id /// grpId of grp held by sending peer @@ -244,6 +224,7 @@ public: }; +#ifdef SUSPENDED_CODE_27042017 /*! * Use to send to peer list of grps * held by server peer @@ -256,17 +237,14 @@ public: RsNxsSessionKeyItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SESSION_KEY_ITEM) { clear(); } virtual ~RsNxsSessionKeyItem() {} - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); /// Session key encrypted for the whole group /// uint8_t iv[EVP_MAX_IV_LENGTH] ; // initialisation vector std::map encrypted_session_keys; // encrypted session keys }; +#endif /*! * Use to send to peer list of grps * held by server peer @@ -282,12 +260,9 @@ public: clear(); } virtual ~RsNxsEncryptedDataItem() {} - - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); /// grpId of grp held by sending peer /// @@ -306,20 +281,14 @@ class RsNxsGrp : public RsNxsItem public: RsNxsGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP_ITEM), grp(servtype), meta(servtype), - metaData(NULL) { clear(); - //std::cout << "\nGrp refcount++ : " << ++refcount << std::endl; - return; } - virtual ~RsNxsGrp() { if(metaData) delete metaData; - //std::cout << "\nGrp refcount-- : " << --refcount << std::endl; - } + metaData(NULL) { clear();} + virtual ~RsNxsGrp() { if(metaData) delete metaData; } RsNxsGrp* clone() const; - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsGxsGroupId grpId; /// group Id, needed to complete version Id (ncvi) static int refcount; @@ -354,13 +323,11 @@ public: #endif static const uint8_t FLAG_USE_HASHED_GROUP_ID; - RsNxsSyncMsgReqItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_MSG_REQ_ITEM) { clear(); return; } - - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; + RsNxsSyncMsgReqItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_MSG_REQ_ITEM) { clear(); } virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsGxsGroupId grpId; uint8_t flag; @@ -380,13 +347,11 @@ public: static const uint8_t FLAG_REQUEST; static const uint8_t FLAG_RESPONSE; static const uint8_t FLAG_USE_SYNC_HASH; - RsNxsSyncMsgItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM) { clear(); return; } + RsNxsSyncMsgItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM) { clear(); } - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint8_t flag; // response/req RsGxsGroupId grpId; @@ -405,24 +370,12 @@ class RsNxsMsg : public RsNxsItem public: RsNxsMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_MSG_ITEM), meta(servtype), msg(servtype), - metaData(NULL) { - // std::cout << "\nrefcount++ : " << ++refcount << std::endl; - clear(); return; - } - virtual ~RsNxsMsg() - { - //std::cout << "\nrefcount-- : " << --refcount << std::endl; - if(metaData){ - //std::cout << "\ndeleted\n"; - delete metaData; - } - } + metaData(NULL) { clear(); } + virtual ~RsNxsMsg() { if(metaData) delete metaData; } - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint8_t pos; /// used for splitting up msg uint8_t count; /// number of split up messages @@ -453,14 +406,11 @@ class RsNxsSearchReqItem : public RsNxsItem { public: - RsNxsSearchReqItem(uint16_t servtype): RsNxsItem(servtype, RS_PKT_SUBTYPE_EXT_SEARCH_REQ), serviceSearchItem(servtype) { return; } - virtual ~RsNxsSearchReqItem() { return;} + RsNxsSearchReqItem(uint16_t servtype): RsNxsItem(servtype, RS_PKT_SUBTYPE_EXT_SEARCH_REQ), serviceSearchItem(servtype) {} + virtual ~RsNxsSearchReqItem() {} + virtual void clear() {} - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - - virtual void clear() { return;} - virtual std::ostream &print(std::ostream &out, uint16_t /*indent*/) { return out; } + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint8_t nHops; /// how many peers to jump to uint32_t token; // search token @@ -477,13 +427,11 @@ class RsNxsSearchResultMsgItem { public: - RsNxsSearchResultMsgItem() : context(0) { return;} + RsNxsSearchResultMsgItem() : context(0) {} - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - void clear() {} - std::ostream &print(std::ostream &out, uint16_t /*indent*/) { return out; } + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t token; // search token to be redeemed RsTlvBinaryData context; // used by client service @@ -504,14 +452,11 @@ public: RsNxsSearchResultGrpItem(); - virtual bool serialise(void *data,uint32_t& size) const; - virtual uint32_t serial_size() const; - void clear() {} - std::ostream &print(std::ostream &out, uint16_t /*indent*/) { return out; } + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t token; // search token to be redeemed - RsTlvBinaryData context; // used by client service std::string grpId; @@ -547,34 +492,16 @@ public: #endif -class RsNxsSerialiser : public RsSerialType +class RsNxsSerialiser : public RsServiceSerializer { public: - RsNxsSerialiser(uint16_t servtype) : - RsSerialType(RS_PKT_VERSION_SERVICE, servtype), SERVICE_TYPE(servtype) { return; } + RsNxsSerialiser(uint16_t servtype) : RsServiceSerializer(servtype), SERVICE_TYPE(servtype) {} + virtual ~RsNxsSerialiser() {} - virtual ~RsNxsSerialiser() { return; } - virtual uint32_t size(RsItem *item); - virtual bool serialise(RsItem *item, void *data, uint32_t *size); - virtual RsItem* deserialise(void *data, uint32_t *size); - -private: - RsNxsSyncGrpReqItem *deserialNxsSyncGrpReqItem(void *data, uint32_t *size); /* RS_PKT_SUBTYPE_SYNC_GRP */ - RsNxsSyncGrpItem *deserialNxsSyncGrpItem(void *data, uint32_t *size); /* RS_PKT_SUBTYPE_SYNC_GRP_ITEM */ - RsNxsSyncMsgReqItem *deserialNxsSyncMsgReqItem(void *data, uint32_t *size); /* RS_PKT_SUBTYPE_SYNC_MSG */ - RsNxsSyncMsgItem *deserialNxsSyncMsgItem(void *data, uint32_t *size); /* RS_PKT_SUBTYPE_SYNC_MSG_ITEM */ - RsNxsGrp *deserialNxsGrpItem(void *data, uint32_t *size); /* RS_PKT_SUBTYPE_NXS_GRP */ - RsNxsMsg *deserialNxsMsgItem(void *data, uint32_t *size); /* RS_PKT_SUBTYPE_NXS_MSG */ - RsNxsTransacItem *deserialNxsTransacItem(void* data, uint32_t *size); /* RS_PKT_SUBTYPE_NXS_TRANS */ - RsNxsGroupPublishKeyItem *deserialNxsGroupPublishKeyItem(void* data, uint32_t *size); /* RS_PKT_SUBTYPE_NXS_GRP_PUBLISH_KEY */ - RsNxsSessionKeyItem *deserialNxsSessionKeyItem(void* data, uint32_t *size); /* RS_PKT_SUBTYPE_NXS_SESSION_KEY_ITEM */ - RsNxsEncryptedDataItem *deserialNxsEncryptedDataItem(void* data, uint32_t *size); /* RS_PKT_SUBTYPE_NXS_ENCRYPTED_DATA_ITEM */ - RsNxsSyncGrpStatsItem *deserialNxsSyncGrpStatsItem(void* data, uint32_t *size); /* RS_PKT_SUBTYPE_NXS_SYNC_GRP_STATS_ITEM */ - - bool checkItemHeader(void *data, uint32_t *size, uint8_t subservice_type); - + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; +protected: const uint16_t SERVICE_TYPE; }; From 22f6d150dfd59135038abe3c6528f87159a1e6dd Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 14:21:46 +0200 Subject: [PATCH 64/94] moved rsnxsitems.cc to rsitems/ --- libretroshare/src/gxs/gxssecurity.h | 3 ++- libretroshare/src/gxs/rsgds.h | 2 +- libretroshare/src/gxs/rsgenexchange.h | 2 +- libretroshare/src/gxs/rsgxsnetservice.h | 2 +- libretroshare/src/gxs/rsgxsnetutils.h | 2 +- libretroshare/src/gxs/rsgxsutil.h | 2 +- libretroshare/src/gxs/rsnxsobserver.h | 2 +- libretroshare/src/libretroshare.pro | 4 ++-- libretroshare/src/{serialiser => rsitems}/rsnxsitems.cc | 0 libretroshare/src/{serialiser => rsitems}/rsnxsitems.h | 0 10 files changed, 10 insertions(+), 9 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsnxsitems.cc (100%) rename libretroshare/src/{serialiser => rsitems}/rsnxsitems.h (100%) diff --git a/libretroshare/src/gxs/gxssecurity.h b/libretroshare/src/gxs/gxssecurity.h index b19f81302..047094688 100644 --- a/libretroshare/src/gxs/gxssecurity.h +++ b/libretroshare/src/gxs/gxssecurity.h @@ -28,7 +28,8 @@ */ #include "serialiser/rstlvkeys.h" -#include "serialiser/rsnxsitems.h" + +#include "rsitems/rsnxsitems.h" #include #include diff --git a/libretroshare/src/gxs/rsgds.h b/libretroshare/src/gxs/rsgds.h index 5a82337fe..303d411b8 100644 --- a/libretroshare/src/gxs/rsgds.h +++ b/libretroshare/src/gxs/rsgds.h @@ -33,7 +33,7 @@ #include "inttypes.h" #include "rsitems/rsgxsitems.h" -#include "serialiser/rsnxsitems.h" +#include "rsitems/rsnxsitems.h" #include "gxs/rsgxsdata.h" #include "rsgxs.h" #include "util/contentvalue.h" diff --git a/libretroshare/src/gxs/rsgenexchange.h b/libretroshare/src/gxs/rsgenexchange.h index 21ea4365c..8ebd40bd7 100644 --- a/libretroshare/src/gxs/rsgenexchange.h +++ b/libretroshare/src/gxs/rsgenexchange.h @@ -36,7 +36,7 @@ #include "rsgxsdataaccess.h" #include "rsnxsobserver.h" #include "retroshare/rsgxsservice.h" -#include "serialiser/rsnxsitems.h" +#include "rsitems/rsnxsitems.h" #include "rsgxsutil.h" template diff --git a/libretroshare/src/gxs/rsgxsnetservice.h b/libretroshare/src/gxs/rsgxsnetservice.h index b14d55058..883649e57 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.h +++ b/libretroshare/src/gxs/rsgxsnetservice.h @@ -33,7 +33,7 @@ #include "rsgds.h" #include "rsnxsobserver.h" #include "pqi/p3linkmgr.h" -#include "serialiser/rsnxsitems.h" +#include "rsitems/rsnxsitems.h" #include "serialiser/rsgxsupdateitems.h" #include "rsgxsnetutils.h" #include "pqi/p3cfgmgr.h" diff --git a/libretroshare/src/gxs/rsgxsnetutils.h b/libretroshare/src/gxs/rsgxsnetutils.h index df82cb2b3..aae2be9f8 100644 --- a/libretroshare/src/gxs/rsgxsnetutils.h +++ b/libretroshare/src/gxs/rsgxsnetutils.h @@ -28,7 +28,7 @@ #include #include "retroshare/rsgxsifacetypes.h" -#include "serialiser/rsnxsitems.h" +#include "rsitems/rsnxsitems.h" #include "rsgixs.h" class p3ServiceControl; diff --git a/libretroshare/src/gxs/rsgxsutil.h b/libretroshare/src/gxs/rsgxsutil.h index a47b981d3..ea94fedcb 100644 --- a/libretroshare/src/gxs/rsgxsutil.h +++ b/libretroshare/src/gxs/rsgxsutil.h @@ -27,7 +27,7 @@ #define GXSUTIL_H_ #include -#include "serialiser/rsnxsitems.h" +#include "rsitems/rsnxsitems.h" #include "rsgds.h" class RsGixs ; diff --git a/libretroshare/src/gxs/rsnxsobserver.h b/libretroshare/src/gxs/rsnxsobserver.h index 2b25fc950..087842ef0 100644 --- a/libretroshare/src/gxs/rsnxsobserver.h +++ b/libretroshare/src/gxs/rsnxsobserver.h @@ -27,7 +27,7 @@ */ #include -#include "serialiser/rsnxsitems.h" +#include "rsitems/rsnxsitems.h" class RsNxsObserver diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 4d2e75c7c..1c047a75b 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -722,7 +722,7 @@ SOURCES += zeroconf/p3zcnatassist.cc \ DEFINES *= SQLITE_HAS_CODEC DEFINES *= GXS_ENABLE_SYNC_MSGS -HEADERS += serialiser/rsnxsitems.h \ +HEADERS += rsitems/rsnxsitems.h \ gxs/rsgds.h \ gxs/rsgxs.h \ gxs/rsdataservice.h \ @@ -748,7 +748,7 @@ HEADERS += serialiser/rsnxsitems.h \ gxs/rsgxsrequesttypes.h -SOURCES += serialiser/rsnxsitems.cc \ +SOURCES += rsitems/rsnxsitems.cc \ gxs/rsdataservice.cc \ gxs/rsgenexchange.cc \ gxs/rsgxsnetservice.cc \ diff --git a/libretroshare/src/serialiser/rsnxsitems.cc b/libretroshare/src/rsitems/rsnxsitems.cc similarity index 100% rename from libretroshare/src/serialiser/rsnxsitems.cc rename to libretroshare/src/rsitems/rsnxsitems.cc diff --git a/libretroshare/src/serialiser/rsnxsitems.h b/libretroshare/src/rsitems/rsnxsitems.h similarity index 100% rename from libretroshare/src/serialiser/rsnxsitems.h rename to libretroshare/src/rsitems/rsnxsitems.h From 35ecc196777e5007066ec65bbc17061a26a752f0 Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 14:41:31 +0200 Subject: [PATCH 65/94] switched rsposteditems to new serialization --- libretroshare/src/serialiser/rsposteditems.cc | 358 +----------------- libretroshare/src/serialiser/rsposteditems.h | 37 +- libretroshare/src/services/p3posted.cc | 1 + 3 files changed, 27 insertions(+), 369 deletions(-) diff --git a/libretroshare/src/serialiser/rsposteditems.cc b/libretroshare/src/serialiser/rsposteditems.cc index e5f8a666e..628a1a1ee 100644 --- a/libretroshare/src/serialiser/rsposteditems.cc +++ b/libretroshare/src/serialiser/rsposteditems.cc @@ -25,365 +25,39 @@ */ #include "serialiser/rsposteditems.h" -#include "rsbaseserial.h" -#include "rstlvbase.h" +#include "serialization/rstypeserializer.h" - -uint32_t RsGxsPostedSerialiser::size(RsItem *item) +void RsGxsPostedPostItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::size()" << std::endl; -#endif - - RsGxsPostedGroupItem* pgItem = NULL; - RsGxsPostedPostItem* ppItem = NULL; - - if ((pgItem = dynamic_cast(item)) != NULL) - { - return sizeGxsPostedGroupItem(pgItem); - } - else if ((ppItem = dynamic_cast(item)) != NULL) - { - return sizeGxsPostedPostItem(ppItem); - } - else - { - return RsGxsCommentSerialiser::size(item); - } + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_LINK,mPost.mLink,"mPost.mLink") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG ,mPost.mNotes,"mPost.mNotes") ; } -bool RsGxsPostedSerialiser::serialise(RsItem *item, void *data, uint32_t *size) +void RsGxsPostedGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::serialise()" << std::endl; -#endif - - RsGxsPostedPostItem* ppItem = NULL; - RsGxsPostedGroupItem* pgItem = NULL; - - if ((pgItem = dynamic_cast(item)) != NULL) - { - return serialiseGxsPostedGroupItem(pgItem, data, size); - } - else if ((ppItem = dynamic_cast(item)) != NULL) - { - return serialiseGxsPostedPostItem(ppItem, data, size); - } - else - { - return RsGxsCommentSerialiser::serialise(item, data, size); - } + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR ,mGroup.mDescription,"mGroup.mDescription") ; } -RsItem* RsGxsPostedSerialiser::deserialise(void *data, uint32_t *size) +RsItem *RsGxsPostedSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const { -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); + if(service_id != RS_SERVICE_GXS_TYPE_POSTED) + return NULL ; - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_POSTED != getRsItemService(rstype))) - { - std::cerr << "RsGxsPostedSerialiser::deserialise() ERROR Wrong Type"; - std::cerr << std::endl; - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_POSTED_GRP_ITEM: - return deserialiseGxsPostedGroupItem(data, size); - break; - case RS_PKT_SUBTYPE_POSTED_POST_ITEM: - return deserialiseGxsPostedPostItem(data, size); - break; - default: - return RsGxsCommentSerialiser::deserialise(data, size); - break; - } + switch(item_subtype) + { + case RS_PKT_SUBTYPE_POSTED_GRP_ITEM: return new RsGxsPostedGroupItem() ; + case RS_PKT_SUBTYPE_POSTED_POST_ITEM: return new RsGxsPostedPostItem() ; + default: + return RsGxsCommentSerialiser::create_item(service_id,item_subtype) ; + } } -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - void RsGxsPostedPostItem::clear() { mPost.mLink.clear(); mPost.mNotes.clear(); } - -std::ostream & RsGxsPostedPostItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsPostedPostItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Link: " << mPost.mLink << std::endl; - printIndent(out, int_Indent); - out << "Notes: " << mPost.mNotes << std::endl; - - printRsItemEnd(out ,"RsGxsPostedPostItem", indent); - return out; -} - -uint32_t RsGxsPostedSerialiser::sizeGxsPostedPostItem(RsGxsPostedPostItem* item) -{ - RsPostedPost& p = item->mPost; - - uint32_t s = 8; - - s += GetTlvStringSize(p.mLink); - s += GetTlvStringSize(p.mNotes); - - return s; -} - -bool RsGxsPostedSerialiser::serialiseGxsPostedPostItem(RsGxsPostedPostItem* item, void* data, uint32_t *size) -{ - -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::serialiseGxsPostedPostItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsPostedPostItem(item); - uint32_t offset = 0; - - if(*size < tlvsize){ - std::cerr << "RsGxsPostedSerialiser::serialiseGxsPostedPostItem() Size too small" << std::endl; - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* RsPostedPost */ - - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LINK, item->mPost.mLink); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->mPost.mNotes); - - if(offset != tlvsize) - { - std::cerr << "RsGxsPostedSerialiser::serialiseGxsPostedPostItem() FAIL Size Error! " << std::endl; - ok = false; - } - -#ifdef POSTED_DEBUG - if (!ok) - { - std::cerr << "RsGxsPostedSerialiser::serialiseGxsPostedPostItem() NOK" << std::endl; - } -#endif - - return ok; -} - - - - -RsGxsPostedPostItem* RsGxsPostedSerialiser::deserialiseGxsPostedPostItem(void *data, uint32_t *size) -{ - -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedPostItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_POSTED != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_POSTED_POST_ITEM != getRsItemSubType(rstype))) - { - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedPostItem() FAIL wrong type" << std::endl; - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedPostItem() FAIL wrong size" << std::endl; - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsPostedPostItem* item = new RsGxsPostedPostItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LINK, item->mPost.mLink); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->mPost.mNotes); - - if (offset != rssize) - { - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedPostItem() FAIL size mismatch" << std::endl; - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedPostItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - void RsGxsPostedGroupItem::clear() { mGroup.mDescription.clear(); - return; } - -std::ostream & RsGxsPostedGroupItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsPostedGroupItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Description: " << mGroup.mDescription << std::endl; - - printRsItemEnd(out ,"RsGxsPostedGroupItem", indent); - return out; -} - - -uint32_t RsGxsPostedSerialiser::sizeGxsPostedGroupItem(RsGxsPostedGroupItem* item) -{ - RsPostedGroup& g = item->mGroup; - uint32_t s = 8; // header - - s += GetTlvStringSize(g.mDescription); - - return s; -} - -bool RsGxsPostedSerialiser::serialiseGxsPostedGroupItem(RsGxsPostedGroupItem* item, void* data, uint32_t *size) -{ - -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::serialiseGxsPostedGroupItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsPostedGroupItem(item); - uint32_t offset = 0; - - if(*size < tlvsize){ -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::serialiseGxsPostedGroupItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* PostedGroupItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DESCR, item->mGroup.mDescription); - - - if(offset != tlvsize) - { -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::serialiseGxsPostedGroupItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef POSTED_DEBUG - if (!ok) - { - std::cerr << "RsGxsPostedSerialiser::serialiseGxsPostedGroupItem() NOK" << std::endl; - } -#endif - - return ok; -} -RsGxsPostedGroupItem* RsGxsPostedSerialiser::deserialiseGxsPostedGroupItem(void *data, uint32_t *size) -{ - -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedGroupItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_POSTED != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_POSTED_GRP_ITEM != getRsItemSubType(rstype))) - { - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedGroupItem() FAIL wrong type" << std::endl; - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedGroupItem() FAIL wrong size" << std::endl; - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsPostedGroupItem* item = new RsGxsPostedGroupItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DESCR, item->mGroup.mDescription); - - if (offset != rssize) - { - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedGroupItem() FAIL size mismatch" << std::endl; - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::deserialiseGxsPostedGroupItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - diff --git a/libretroshare/src/serialiser/rsposteditems.h b/libretroshare/src/serialiser/rsposteditems.h index e78dfafe1..b78835451 100644 --- a/libretroshare/src/serialiser/rsposteditems.h +++ b/libretroshare/src/serialiser/rsposteditems.h @@ -7,18 +7,17 @@ #include "retroshare/rsposted.h" -const uint8_t RS_PKT_SUBTYPE_POSTED_GRP_ITEM = 0x02; +const uint8_t RS_PKT_SUBTYPE_POSTED_GRP_ITEM = 0x02; const uint8_t RS_PKT_SUBTYPE_POSTED_POST_ITEM = 0x03; class RsGxsPostedGroupItem : public RsGxsGrpItem { public: - RsGxsPostedGroupItem() : RsGxsGrpItem(RS_SERVICE_GXS_TYPE_POSTED, - RS_PKT_SUBTYPE_POSTED_GRP_ITEM) { return; } - virtual ~RsGxsPostedGroupItem() { return; } + RsGxsPostedGroupItem() : RsGxsGrpItem(RS_SERVICE_GXS_TYPE_POSTED, RS_PKT_SUBTYPE_POSTED_GRP_ITEM) {} + virtual ~RsGxsPostedGroupItem() {} void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsPostedGroup mGroup; }; @@ -26,40 +25,24 @@ public: class RsGxsPostedPostItem : public RsGxsMsgItem { public: - RsGxsPostedPostItem() : RsGxsMsgItem(RS_SERVICE_GXS_TYPE_POSTED, - RS_PKT_SUBTYPE_POSTED_POST_ITEM) {return ; } - virtual ~RsGxsPostedPostItem() { return; } + RsGxsPostedPostItem() : RsGxsMsgItem(RS_SERVICE_GXS_TYPE_POSTED, RS_PKT_SUBTYPE_POSTED_POST_ITEM) {} + virtual ~RsGxsPostedPostItem() {} void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsPostedPost mPost; }; class RsGxsPostedSerialiser : public RsGxsCommentSerialiser { - public: - RsGxsPostedSerialiser() - :RsGxsCommentSerialiser(RS_SERVICE_GXS_TYPE_POSTED) - { return; } + RsGxsPostedSerialiser() :RsGxsCommentSerialiser(RS_SERVICE_GXS_TYPE_POSTED) {} - virtual ~RsGxsPostedSerialiser() { return; } + virtual ~RsGxsPostedSerialiser() {} - uint32_t size(RsItem *item); - bool serialise(RsItem *item, void *data, uint32_t *size); - RsItem* deserialise(void *data, uint32_t *size); - -private: - - uint32_t sizeGxsPostedGroupItem(RsGxsPostedGroupItem* item); - bool serialiseGxsPostedGroupItem(RsGxsPostedGroupItem* item, void* data, uint32_t *size); - RsGxsPostedGroupItem* deserialiseGxsPostedGroupItem(void *data, uint32_t *size); - - uint32_t sizeGxsPostedPostItem(RsGxsPostedPostItem* item); - bool serialiseGxsPostedPostItem(RsGxsPostedPostItem* item, void* data, uint32_t *size); - RsGxsPostedPostItem* deserialiseGxsPostedPostItem(void *data, uint32_t *size); + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; }; diff --git a/libretroshare/src/services/p3posted.cc b/libretroshare/src/services/p3posted.cc index b231149d5..1fe9dde3f 100644 --- a/libretroshare/src/services/p3posted.cc +++ b/libretroshare/src/services/p3posted.cc @@ -156,6 +156,7 @@ bool p3Posted::getPostData(const uint32_t &token, std::vector &msg std::cerr << "Not a PostedPostItem neither a RsGxsCommentItem" << " PacketService=" << std::hex << (int)msg->PacketService() << std::dec << " PacketSubType=" << std::hex << (int)msg->PacketSubType() << std::dec + << " type name =" << typeid(*msg).name() << " , deleting!" << std::endl; delete *vit; } From 349d14b354645cc33a0f44bb2671e658e91f732e Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 14:44:41 +0200 Subject: [PATCH 66/94] moved rsposteditems to rsitems/ --- libretroshare/src/libretroshare.pro | 4 ++-- libretroshare/src/{serialiser => rsitems}/rsposteditems.cc | 2 +- libretroshare/src/{serialiser => rsitems}/rsposteditems.h | 0 libretroshare/src/services/p3posted.cc | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsposteditems.cc (95%) rename libretroshare/src/{serialiser => rsitems}/rsposteditems.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 1c047a75b..a86b8b9e4 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -844,11 +844,11 @@ gxsthewire { HEADERS += services/p3postbase.h \ services/p3posted.h \ retroshare/rsposted.h \ - serialiser/rsposteditems.h + rsitems/rsposteditems.h SOURCES += services/p3postbase.cc \ services/p3posted.cc \ - serialiser/rsposteditems.cc + rsitems/rsposteditems.cc gxsphotoshare { #Photo Service diff --git a/libretroshare/src/serialiser/rsposteditems.cc b/libretroshare/src/rsitems/rsposteditems.cc similarity index 95% rename from libretroshare/src/serialiser/rsposteditems.cc rename to libretroshare/src/rsitems/rsposteditems.cc index 628a1a1ee..652abed05 100644 --- a/libretroshare/src/serialiser/rsposteditems.cc +++ b/libretroshare/src/rsitems/rsposteditems.cc @@ -24,7 +24,7 @@ * */ -#include "serialiser/rsposteditems.h" +#include "rsitems/rsposteditems.h" #include "serialization/rstypeserializer.h" void RsGxsPostedPostItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) diff --git a/libretroshare/src/serialiser/rsposteditems.h b/libretroshare/src/rsitems/rsposteditems.h similarity index 100% rename from libretroshare/src/serialiser/rsposteditems.h rename to libretroshare/src/rsitems/rsposteditems.h diff --git a/libretroshare/src/services/p3posted.cc b/libretroshare/src/services/p3posted.cc index 1fe9dde3f..b3ad80ddf 100644 --- a/libretroshare/src/services/p3posted.cc +++ b/libretroshare/src/services/p3posted.cc @@ -24,7 +24,7 @@ */ #include "services/p3posted.h" -#include "serialiser/rsposteditems.h" +#include "rsitems/rsposteditems.h" #include From 9adbab32816a5ce1c4a205fb835fb27e8f673073 Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 21:10:22 +0200 Subject: [PATCH 67/94] switched heartbeatitems to new serialization --- libretroshare/src/libretroshare.pro | 3 +- .../src/serialiser/rsheartbeatitems.cc | 7 ++-- .../src/serialiser/rsheartbeatitems.h | 34 ++++++++----------- libretroshare/src/services/p3heartbeat.cc | 2 +- 4 files changed, 19 insertions(+), 27 deletions(-) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index a86b8b9e4..de265a388 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -483,7 +483,7 @@ HEADERS += rsitems/rsitem.h \ rsitems/rsbanlistitems.h \ rsitems/rsbwctrlitems.h \ rsitems/rsdiscovery2items.h \ - serialiser/rsheartbeatitems.h \ + rsitems/rsheartbeatitems.h \ rsitems/rsrttitems.h \ serialiser/rsgxsrecognitems.h \ serialiser/rsgxsupdateitems.h \ @@ -631,7 +631,6 @@ SOURCES += serialiser/rsbaseserial.cc \ rsitems/rsbanlistitems.cc \ rsitems/rsbwctrlitems.cc \ rsitems/rsdiscovery2items.cc \ - serialiser/rsheartbeatitems.cc \ rsitems/rsrttitems.cc \ serialiser/rsgxsrecognitems.cc \ serialiser/rsgxsupdateitems.cc \ diff --git a/libretroshare/src/serialiser/rsheartbeatitems.cc b/libretroshare/src/serialiser/rsheartbeatitems.cc index 0151525a2..f3a1db0c0 100644 --- a/libretroshare/src/serialiser/rsheartbeatitems.cc +++ b/libretroshare/src/serialiser/rsheartbeatitems.cc @@ -24,6 +24,7 @@ * */ +#ifdef TO_REMOVE #include "serialiser/rsbaseserial.h" #include "rsitems/rsserviceids.h" #include "serialiser/rsheartbeatitems.h" @@ -91,10 +92,6 @@ RsItem *RsHeartbeatSerialiser::deserialise(void *data, uint32_t *pktsize) /*************************************************************************/ -void RsHeartbeatItem::clear() -{ -} - std::ostream &RsHeartbeatItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsHeartbeatItem", indent); @@ -204,3 +201,5 @@ RsHeartbeatItem *RsHeartbeatSerialiser::deserialiseHeartbeat(void *data, uint32_ /*************************************************************************/ + +#endif diff --git a/libretroshare/src/serialiser/rsheartbeatitems.h b/libretroshare/src/serialiser/rsheartbeatitems.h index 3a9e6e95f..87d480b3e 100644 --- a/libretroshare/src/serialiser/rsheartbeatitems.h +++ b/libretroshare/src/serialiser/rsheartbeatitems.h @@ -28,9 +28,8 @@ #ifndef RS_HEARTBEAT_ITEMS_H #define RS_HEARTBEAT_ITEMS_H -#include "serialiser/rsserial.h" -#include "rsitems/rsserviceids.h" #include "rsitems/rsitem.h" +#include "rsitems/rsserviceids.h" #include "rsitems/itempriorities.h" const uint8_t RS_PKT_SUBTYPE_HEARTBEAT_PULSE = 0x01; @@ -43,30 +42,25 @@ public: setPriorityLevel(QOS_PRIORITY_RS_HEARTBEAT_PULSE) ; } virtual ~RsHeartbeatItem() {} + virtual void serial_process(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) {} - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void clear(){} }; -class RsHeartbeatSerialiser: public RsSerialType +class RsHeartbeatSerialiser: public RsServiceSerializer { - public: - RsHeartbeatSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_HEARTBEAT) - { return; } +public: + RsHeartbeatSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_HEARTBEAT) {} -virtual ~RsHeartbeatSerialiser() { return; } - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - -virtual uint32_t sizeHeartbeat(RsHeartbeatItem *); -virtual bool serialiseHeartbeat(RsHeartbeatItem *item, void *data, uint32_t *size); -virtual RsHeartbeatItem *deserialiseHeartbeat(void *data, uint32_t *size); + virtual ~RsHeartbeatSerialiser() {} + virtual RsItem *create_item(uint16_t service,uint8_t item_subtype) const + { + if(service == RS_SERVICE_TYPE_HEARTBEAT && item_subtype == RS_PKT_SUBTYPE_HEARTBEAT_PULSE) + return new RsHeartbeatItem() ; + else + return NULL ; + } }; diff --git a/libretroshare/src/services/p3heartbeat.cc b/libretroshare/src/services/p3heartbeat.cc index 40a510165..498a88cfa 100644 --- a/libretroshare/src/services/p3heartbeat.cc +++ b/libretroshare/src/services/p3heartbeat.cc @@ -26,7 +26,7 @@ #include #include "services/p3heartbeat.h" -#include "serialiser/rsheartbeatitems.h" +#include "rsitems/rsheartbeatitems.h" #include "pqi/p3servicecontrol.h" #include "pqi/pqipersongrp.h" From 07a93be1b2de5500a95857401c12e30763d00a10 Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 21:11:10 +0200 Subject: [PATCH 68/94] moved heartbeatitem.h to rsitems/ --- .../rsheartbeatitems.h | 0 .../src/serialiser/rsheartbeatitems.cc | 205 ------------------ 2 files changed, 205 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsheartbeatitems.h (100%) delete mode 100644 libretroshare/src/serialiser/rsheartbeatitems.cc diff --git a/libretroshare/src/serialiser/rsheartbeatitems.h b/libretroshare/src/rsitems/rsheartbeatitems.h similarity index 100% rename from libretroshare/src/serialiser/rsheartbeatitems.h rename to libretroshare/src/rsitems/rsheartbeatitems.h diff --git a/libretroshare/src/serialiser/rsheartbeatitems.cc b/libretroshare/src/serialiser/rsheartbeatitems.cc deleted file mode 100644 index f3a1db0c0..000000000 --- a/libretroshare/src/serialiser/rsheartbeatitems.cc +++ /dev/null @@ -1,205 +0,0 @@ - -/* - * libretroshare/src/serialiser: rsheartbeatitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2013-2013 by Robert Fernie. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License Version 2.1 as published by the Free Software Foundation. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA. - * - * Please report all bugs and problems to "retroshare@lunamutt.com". - * - */ - -#ifdef TO_REMOVE -#include "serialiser/rsbaseserial.h" -#include "rsitems/rsserviceids.h" -#include "serialiser/rsheartbeatitems.h" - -/*** - * #define HEART_DEBUG 1 - ***/ - -#define HEART_DEBUG 1 - -#include - -/*************************************************************************/ - -uint32_t RsHeartbeatSerialiser::size(RsItem *i) -{ - RsHeartbeatItem *beat; - - if (NULL != (beat = dynamic_cast(i))) - { - return sizeHeartbeat(beat); - } - return 0; -} - -/* serialise the data to the buffer */ -bool RsHeartbeatSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsHeartbeatItem *beat; - - if (NULL != (beat = dynamic_cast(i))) - { - return serialiseHeartbeat(beat, data, pktsize); - } - return false; -} - -RsItem *RsHeartbeatSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_HEARTBEAT != getRsItemService(rstype))) - { - -#ifdef HEART_DEBUG - std::cerr << "RsHeartbeatSerialiser::deserialise() Wrong Type" << std::endl; -#endif - return NULL; - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_HEARTBEAT_PULSE: - return deserialiseHeartbeat(data, pktsize); - break; - default: - return NULL; - break; - } - return NULL; -} - -/*************************************************************************/ - - -std::ostream &RsHeartbeatItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsHeartbeatItem", indent); - printRsItemEnd(out, "RsHeartbeatItem", indent); - return out; -} - -uint32_t RsHeartbeatSerialiser::sizeHeartbeat(RsHeartbeatItem */*item*/) -{ - uint32_t s = 8; /* header */ - return s; -} - -/* serialise the data to the buffer */ -bool RsHeartbeatSerialiser::serialiseHeartbeat(RsHeartbeatItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeHeartbeat(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - { -#ifdef HEART_DEBUG - std::cerr << "RsHeartbeatSerialiser::serialiseHeartbeat() Not enough space" << std::endl; -#endif - return false; /* not enough space */ - } - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, *pktsize, item->PacketId(), *pktsize); - - /* skip the header */ - offset += 8; - - if (offset != tlvsize) - { -#ifdef HEART_DEBUG - std::cerr << "RsHeartbeatSerialiser::serialiseHeartbeat() size error" << std::endl; -#endif - ok = false; - } - - return ok; -} - -RsHeartbeatItem *RsHeartbeatSerialiser::deserialiseHeartbeat(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_HEARTBEAT != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_HEARTBEAT_PULSE != getRsItemSubType(rstype))) - { -#ifdef HEART_DEBUG - std::cerr << "RsHeartbeatSerialiser::deserialiseHeartbeat() Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - { -#ifdef HEART_DEBUG - std::cerr << "RsHeartbeatSerialiser::deserialiseHeartbeat() size error" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsHeartbeatItem *item = new RsHeartbeatItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - if (offset != rssize) - { -#ifdef HEART_DEBUG - std::cerr << "RsHeartbeatSerialiser::deserialiseHeartbeat() size error2" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef HEART_DEBUG - std::cerr << "RsHeartbeatSerialiser::deserialiseHeartbeat() ok = false" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -/*************************************************************************/ - -#endif From 87018edeb2907fc2ed6172bc707785984411697e Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 21:20:30 +0200 Subject: [PATCH 69/94] switched rsstatusitem to new serializer --- libretroshare/src/serialiser/rsstatusitems.cc | 3 ++ libretroshare/src/serialiser/rsstatusitems.h | 49 +++++++++---------- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/libretroshare/src/serialiser/rsstatusitems.cc b/libretroshare/src/serialiser/rsstatusitems.cc index e39c4f56c..d41d8c7ba 100644 --- a/libretroshare/src/serialiser/rsstatusitems.cc +++ b/libretroshare/src/serialiser/rsstatusitems.cc @@ -23,6 +23,7 @@ * */ +#ifdef TO_REMOVE #include "serialiser/rsstatusitems.h" #include "serialiser/rsbaseserial.h" @@ -173,3 +174,5 @@ RsItem *RsStatusSerialiser::deserialise(void *data, uint32_t *pktsize) } /*************************************************************************/ + +#endif diff --git a/libretroshare/src/serialiser/rsstatusitems.h b/libretroshare/src/serialiser/rsstatusitems.h index 8ea99e04c..8c0316a9b 100644 --- a/libretroshare/src/serialiser/rsstatusitems.h +++ b/libretroshare/src/serialiser/rsstatusitems.h @@ -30,49 +30,46 @@ #include "rsitems/itempriorities.h" #include "rsitems/rsitem.h" +#include "serialization/rstypeserializer.h" + /**************************************************************************/ class RsStatusItem: public RsItem { - public: - RsStatusItem() - :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_STATUS, - RS_PKT_SUBTYPE_DEFAULT) +public: + RsStatusItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_STATUS, RS_PKT_SUBTYPE_DEFAULT) { setPriorityLevel(QOS_PRIORITY_RS_STATUS_ITEM); } -virtual ~RsStatusItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual ~RsStatusItem() {} + virtual void clear() {} + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) + { + RsTypeSerializer::serial_process(j,ctx,sendTime,"sendTime") ; + RsTypeSerializer::serial_process(j,ctx,status ,"status") ; + } uint32_t sendTime; - uint32_t status; /* not serialised */ uint32_t recvTime; }; -class RsStatusSerialiser: public RsSerialType +class RsStatusSerialiser: public RsServiceSerializer { - public: - RsStatusSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_STATUS) - { return; } -virtual ~RsStatusSerialiser() - { return; } - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - -virtual uint32_t sizeItem(RsStatusItem *); -virtual bool serialiseItem (RsStatusItem *item, void *data, uint32_t *size); -virtual RsStatusItem *deserialiseItem(void *data, uint32_t *size); - +public: + RsStatusSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_STATUS) {} + virtual ~RsStatusSerialiser() {} + virtual RsItem *create_item(uint16_t service,uint8_t item_subtype) const + { + if(service == RS_SERVICE_TYPE_STATUS && item_subtype == RS_PKT_SUBTYPE_DEFAULT) + return new RsStatusItem(); + else + return NULL ; + } }; /**************************************************************************/ From 5995e508c567f4e28f35c5d29e8fa2e81d5371be Mon Sep 17 00:00:00 2001 From: csoler Date: Thu, 27 Apr 2017 21:24:27 +0200 Subject: [PATCH 70/94] moved rsstatusitem.h to rsitems/ --- libretroshare/src/libretroshare.pro | 3 +- .../{serialiser => rsitems}/rsstatusitems.h | 0 libretroshare/src/serialiser/rsstatusitems.cc | 178 ------------------ libretroshare/src/services/p3statusservice.cc | 2 +- libretroshare/src/services/p3statusservice.h | 2 +- 5 files changed, 3 insertions(+), 182 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsstatusitems.h (100%) delete mode 100644 libretroshare/src/serialiser/rsstatusitems.cc diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index de265a388..455ad9d33 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -463,7 +463,7 @@ HEADERS += rsitems/rsitem.h \ serialiser/rsserial.h \ rsitems/rsserviceids.h \ serialiser/rsserviceitems.h \ - serialiser/rsstatusitems.h \ + rsitems/rsstatusitems.h \ serialiser/rstlvaddrs.h \ serialiser/rstlvbase.h \ serialiser/rstlvitem.h \ @@ -615,7 +615,6 @@ SOURCES += serialiser/rsbaseserial.cc \ rsitems/rshistoryitems.cc \ rsitems/rsmsgitems.cc \ serialiser/rsserial.cc \ - serialiser/rsstatusitems.cc \ serialiser/rstlvaddrs.cc \ serialiser/rstlvbase.cc \ serialiser/rstlvitem.cc \ diff --git a/libretroshare/src/serialiser/rsstatusitems.h b/libretroshare/src/rsitems/rsstatusitems.h similarity index 100% rename from libretroshare/src/serialiser/rsstatusitems.h rename to libretroshare/src/rsitems/rsstatusitems.h diff --git a/libretroshare/src/serialiser/rsstatusitems.cc b/libretroshare/src/serialiser/rsstatusitems.cc deleted file mode 100644 index d41d8c7ba..000000000 --- a/libretroshare/src/serialiser/rsstatusitems.cc +++ /dev/null @@ -1,178 +0,0 @@ -/* - * libretroshare/src/serialiser: rsstatusitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2007-2008 by Vinny Do. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License Version 2 as published by the Free Software Foundation. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA. - * - * Please report all bugs and problems to "retroshare@lunamutt.com". - * - */ - -#ifdef TO_REMOVE -#include "serialiser/rsstatusitems.h" -#include "serialiser/rsbaseserial.h" - -/*** -#define RSSERIAL_DEBUG 1 -***/ - -#include - -/*************************************************************************/ - -RsStatusItem::~RsStatusItem() -{ - return; -} - -void RsStatusItem::clear() -{ - sendTime = 0; - status = 0; -} - -std::ostream &RsStatusItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsStatusItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "sendTime: " << sendTime << std::endl; - - printIndent(out, int_Indent); - out << "status: " << status << std::endl; - - printRsItemEnd(out, "RsStatusItem", indent); - return out; -} - -uint32_t RsStatusSerialiser::sizeItem(RsStatusItem */*item*/) -{ - uint32_t s = 8; /* header */ - s += 4; /* sendTime */ - s += 4; /* status */ - - return s; -} - -/* serialise the data to the buffer */ -bool RsStatusSerialiser::serialiseItem(RsStatusItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeItem(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsStatusSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsStatusSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, item->sendTime); - ok &= setRawUInt32(data, tlvsize, &offset, item->status); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsStatusSerialiser::serialiseItem() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsStatusItem *RsStatusSerialiser::deserialiseItem(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_STATUS != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_DEFAULT != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsStatusItem *item = new RsStatusItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &(item->sendTime)); - ok &= getRawUInt32(data, rssize, &offset, &(item->status)); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -uint32_t RsStatusSerialiser::size(RsItem *item) -{ - return sizeItem((RsStatusItem *) item); -} - -bool RsStatusSerialiser::serialise(RsItem *item, void *data, uint32_t *pktsize) -{ - return serialiseItem((RsStatusItem *) item, data, pktsize); -} - -RsItem *RsStatusSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - return deserialiseItem(data, pktsize); -} - -/*************************************************************************/ - -#endif diff --git a/libretroshare/src/services/p3statusservice.cc b/libretroshare/src/services/p3statusservice.cc index c80740462..54184f4db 100644 --- a/libretroshare/src/services/p3statusservice.cc +++ b/libretroshare/src/services/p3statusservice.cc @@ -24,7 +24,7 @@ */ #include "services/p3statusservice.h" -#include "serialiser/rsstatusitems.h" +#include "rsitems/rsstatusitems.h" #include "rsserver/p3face.h" #include "retroshare/rsiface.h" diff --git a/libretroshare/src/services/p3statusservice.h b/libretroshare/src/services/p3statusservice.h index 16395976e..c4f730b0d 100644 --- a/libretroshare/src/services/p3statusservice.h +++ b/libretroshare/src/services/p3statusservice.h @@ -29,7 +29,7 @@ #include #include -#include "serialiser/rsstatusitems.h" +#include "rsitems/rsstatusitems.h" #include "retroshare/rsstatus.h" #include "services/p3service.h" #include "pqi/p3cfgmgr.h" From 2e6766569d4e7f4f07503f88174d8163a0a97c30 Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 16:26:59 +0200 Subject: [PATCH 71/94] switched MsgUpdate items to new serialization --- .../src/serialiser/rsgxsupdateitems.cc | 660 ++---------------- .../src/serialiser/rsgxsupdateitems.h | 75 +- .../src/serialization/rstypeserializer.h | 20 +- 3 files changed, 71 insertions(+), 684 deletions(-) diff --git a/libretroshare/src/serialiser/rsgxsupdateitems.cc b/libretroshare/src/serialiser/rsgxsupdateitems.cc index 0074b23c9..f0a7912b3 100644 --- a/libretroshare/src/serialiser/rsgxsupdateitems.cc +++ b/libretroshare/src/serialiser/rsgxsupdateitems.cc @@ -23,9 +23,32 @@ * */ +#include "serialization/rstypeserializer.h" + #include "rsgxsupdateitems.h" #include "rsbaseserial.h" +/**********************************************************************************************/ +/* SERIALIZER */ +/**********************************************************************************************/ + +RsItem* RsGxsUpdateSerialiser::create_item(uint16_t service,uint8_t item_subtype) const +{ + if(service != SERVICE_TYPE) + return NULL ; + + switch(item_subtype) + { + case RS_PKT_SUBTYPE_GXS_MSG_UPDATE: return new RsGxsMsgUpdateItem(SERVICE_TYPE); + case RS_PKT_SUBTYPE_GXS_GRP_UPDATE: return new RsGxsGrpUpdateItem(SERVICE_TYPE); + case RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE: return new RsGxsServerGrpUpdateItem(SERVICE_TYPE); + case RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE: return new RsGxsServerMsgUpdateItem(SERVICE_TYPE); + case RS_PKT_SUBTYPE_GXS_GRP_CONFIG: return new RsGxsGrpConfigItem(SERVICE_TYPE); + default: + return NULL ; + } +} + /**********************************************************************************************/ /* CLEAR */ /**********************************************************************************************/ @@ -53,642 +76,63 @@ void RsGxsServerGrpUpdateItem::clear() grpUpdateTS = 0; } - - /**********************************************************************************************/ -/* PRINT */ +/* SERIALISER */ /**********************************************************************************************/ -std::ostream& RsGxsMsgUpdateItem::print(std::ostream& out, uint16_t indent) +void RsGxsGrpUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - RsPeerId peerId; - std::map msgUpdateTS; - - printRsItemBase(out, "RsGxsMsgUpdateItem", indent); - uint16_t int_Indent = indent + 2; - out << "peerId: " << peerId << std::endl; - printIndent(out, int_Indent); - - std::map::const_iterator cit = msgUpdateInfos.begin(); - out << "msgUpdateTS map:" << std::endl; - int_Indent += 2; - for(; cit != msgUpdateInfos.end(); ++cit) - { - out << "grpId: " << cit->first << std::endl; - printIndent(out, int_Indent); - out << "Msg time stamp: " << cit->second.time_stamp << std::endl; - printIndent(out, int_Indent); - out << "posts available: " << cit->second.message_count << std::endl; - printIndent(out, int_Indent); - } - - return out; -} -std::ostream& RsGxsGrpUpdateItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsGrpUpdateItem", indent); - uint16_t int_Indent = indent + 2; - out << "peerId: " << peerID << std::endl; - printIndent(out, int_Indent); - out << "grpUpdateTS: " << grpUpdateTS << std::endl; - printIndent(out, int_Indent); - return out ; + RsTypeSerializer::serial_process (j,ctx,peerID,"peerID"); + RsTypeSerializer::serial_process(j,ctx,grpUpdateTS,"grpUpdateTS"); } -std::ostream& RsGxsServerMsgUpdateItem::print(std::ostream& out, uint16_t indent) +void RsGxsServerGrpUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - printRsItemBase(out, "RsGxsServerMsgUpdateItem", indent); - uint16_t int_Indent = indent + 2; - out << "grpId: " << grpId << std::endl; - printIndent(out, int_Indent); - out << "msgUpdateTS: " << msgUpdateTS << std::endl; - printIndent(out, int_Indent); - return out; + RsTypeSerializer::serial_process(j,ctx,grpUpdateTS,"grpUpdateTS"); } - -std::ostream& RsGxsServerGrpUpdateItem::print(std::ostream& out, uint16_t indent) +void RsGxsMsgUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - printRsItemBase(out, "RsGxsServerGrpUpdateItem", indent); - uint16_t int_Indent = indent + 2; - out << "grpUpdateTS: " << grpUpdateTS << std::endl; - printIndent(out, int_Indent); - - return out; + RsTypeSerializer::serial_process(j,ctx,peerID,"peerID"); + RsTypeSerializer::serial_process(j,ctx,msgUpdateInfos,"msgUpdateInfos"); } -/**********************************************************************************************/ -/* SERIALISER */ -/**********************************************************************************************/ - -bool RsGxsNetServiceItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const RsGxsMsgUpdateItem::MsgUpdateInfo& info) { - tlvsize = serial_size() ; - offset = 0; + bool ok = true ; - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsFileTransferItem::serialise_header(): ERROR. Not enough size!" << std::endl; - return false ; - } -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileItemSerialiser::serialiseData() Header: " << ok << std::endl; -#endif - offset += 8; - - return true ; -} -RsItem* RsGxsUpdateSerialiser::deserialise(void* data, uint32_t* size) -{ - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (SERVICE_TYPE != getRsItemService(rstype))) - return NULL; /* wrong type */ - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_GXS_MSG_UPDATE: return deserialGxsMsgUpdate(data, size); - case RS_PKT_SUBTYPE_GXS_GRP_UPDATE: return deserialGxsGrpUpddate(data, size); - case RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE: return deserialGxsServerGrpUpddate(data, size); - case RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE: return deserialGxsServerMsgUpdate(data, size); - case RS_PKT_SUBTYPE_GXS_GRP_CONFIG: return deserialGxsGrpConfig(data, size); - - default: - { -# ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialise() : data has no type" - << std::endl; -# endif - return NULL; - - } - } -} - -/**********************************************************************************************/ -/* SERIAL_SIZE() */ -/**********************************************************************************************/ - - -uint32_t RsGxsGrpUpdateItem::serial_size() const -{ - uint32_t s = 8; // header size - s += peerID.serial_size(); - s += 4; // mUpdateTS - return s; -} - -uint32_t RsGxsServerGrpUpdateItem::serial_size() const -{ - uint32_t s = 8; // header size - s += 4; // time stamp - return s; -} - -uint32_t RsGxsMsgUpdateItem::serial_size() const -{ - uint32_t s = 8; // header size - s += peerID.serial_size() ;//GetTlvStringSize(item->peerId); - - s += msgUpdateInfos.size() * (4 + 4 + RsGxsGroupId::serial_size()); - s += 4; // number of map items - - return s; -} - -uint32_t RsGxsServerMsgUpdateItem::serial_size() const -{ - uint32_t s = 8; // header size - s += grpId.serial_size(); - s += 4; // grp TS - - return s; -} -uint32_t RsGxsGrpConfigItem::serial_size() const -{ - uint32_t s = 8; // header size - s += grpId.serial_size(); - s += 4; // msg_keep_delay - s += 4; // msg_send_delay - s += 4; // msg_req_delay - - return s; -} - -/**********************************************************************************************/ -/* SERIALISE() */ -/**********************************************************************************************/ - -bool RsGxsGrpUpdateItem::serialise(void* data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= peerID.serialise(data, size, offset) ; - ok &= setRawUInt32(data, size, &offset, grpUpdateTS); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::serialiseGxsGrpUpdate() FAIL Size Error! " << std::endl; -#endif - ok = false; - } + ok = ok && setRawUInt32(data,size,&offset,info.time_stamp); + ok = ok && setRawUInt32(data,size,&offset,info.message_count); return ok; } - -bool RsGxsServerGrpUpdateItem::serialise(void* data, uint32_t& size) const +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, RsGxsMsgUpdateItem::MsgUpdateInfo& info) { - uint32_t tlvsize,offset=0; - bool ok = true; + bool ok = true ; - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* RsGxsServerGrpUpdateItem */ - - ok &= setRawUInt32(data, size, &offset, grpUpdateTS); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerGrpUpdate() FAIL Size Error! " << std::endl; -#endif - ok = false; - } + ok = ok && getRawUInt32(data,size,&offset,&info.time_stamp); + ok = ok && getRawUInt32(data,size,&offset,&info.message_count); return ok; } -bool RsGxsMsgUpdateItem::serialise(void* data, uint32_t& size) const +template<> uint32_t RsTypeSerializer::serial_size(const RsGxsMsgUpdateItem::MsgUpdateInfo& /* info */) { return 8; } + +template<> void RsTypeSerializer::print_data(const std::string& name,const RsGxsMsgUpdateItem::MsgUpdateInfo& info) { - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= peerID.serialise(data, size, offset) ; - - std::map::const_iterator cit(msgUpdateInfos.begin()); - - uint32_t numItems = msgUpdateInfos.size(); - ok &= setRawUInt32(data, size, &offset, numItems); - - for(; cit != msgUpdateInfos.end(); ++cit) - { - ok &= cit->first.serialise(data, size, offset); - ok &= setRawUInt32(data, size, &offset, cit->second.time_stamp); - ok &= setRawUInt32(data, size, &offset, cit->second.message_count); - } - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::serialiseGxsMsgUpdate() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - - return ok; + std::cerr << "[MsgUpdateInfo]: " << name << ": " << info.time_stamp << ", " << info.message_count << std::endl; } -bool RsGxsServerMsgUpdateItem::serialise( void* data, uint32_t& size) const +void RsGxsServerMsgUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= grpId.serialise(data, size, offset) ; - ok &= setRawUInt32(data, size, &offset, msgUpdateTS); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerMsgUpdate() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - - return ok; + RsTypeSerializer::serial_process (j,ctx,grpId,"grpId"); + RsTypeSerializer::serial_process(j,ctx,msgUpdateTS,"msgUpdateTS"); } - -bool RsGxsGrpConfigItem::serialise( void* data, uint32_t& size) const +void RsGxsGrpConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= grpId.serialise(data, size, offset) ; - ok &= setRawUInt32(data, size, &offset, msg_keep_delay); - ok &= setRawUInt32(data, size, &offset, msg_send_delay); - ok &= setRawUInt32(data, size, &offset, msg_req_delay); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::serialiseGxsServerMsgUpdate() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - - return ok; + RsTypeSerializer::serial_process (j,ctx,grpId,"grpId") ; + RsTypeSerializer::serial_process(j,ctx,msg_keep_delay,"msg_keep_delay") ; + RsTypeSerializer::serial_process(j,ctx,msg_send_delay,"msg_send_delay") ; + RsTypeSerializer::serial_process(j,ctx,msg_req_delay,"msg_req_delay") ; } -/**********************************************************************************************/ -/* DESERIALISE() */ -/**********************************************************************************************/ - -RsGxsGrpConfigItem* RsGxsUpdateSerialiser::deserialGxsGrpConfig(void* data, uint32_t* size) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (SERVICE_TYPE != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_GXS_GRP_CONFIG != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsGrpConfigItem* item = new RsGxsGrpConfigItem(getRsItemService(rstype)); - - /* skip the header */ - offset += 8; - - ok &= item->grpId.deserialise(data, *size, offset) ; - ok &= getRawUInt32(data, *size, &offset, &(item->msg_keep_delay)); - ok &= getRawUInt32(data, *size, &offset, &(item->msg_send_delay)); - ok &= getRawUInt32(data, *size, &offset, &(item->msg_req_delay)); - - if (offset != rssize) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxxGrpUpdate() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} -RsGxsGrpUpdateItem* RsGxsUpdateSerialiser::deserialGxsGrpUpddate(void* data, uint32_t* size) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (SERVICE_TYPE != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXS_GRP_UPDATE != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsGrpUpdateItem* item = new RsGxsGrpUpdateItem(getRsItemService(rstype)); - - /* skip the header */ - offset += 8; - - ok &= item->peerID.deserialise(data, *size, offset) ; - ok &= getRawUInt32(data, *size, &offset, &(item->grpUpdateTS)); - - if (offset != rssize) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxxGrpUpdate() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsGrpUpdate() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -RsGxsServerGrpUpdateItem* RsGxsUpdateSerialiser::deserialGxsServerGrpUpddate(void* data, uint32_t* size) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (SERVICE_TYPE != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsServerGrpUpdateItem* item = new RsGxsServerGrpUpdateItem(getRsItemService(rstype)); - - /* skip the header */ - offset += 8; - - ok &= getRawUInt32(data, *size, &offset, &(item->grpUpdateTS)); - - if (offset != rssize) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerGrpUpdate() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - - -RsGxsMsgUpdateItem* RsGxsUpdateSerialiser::deserialGxsMsgUpdate(void* data, uint32_t* size) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (SERVICE_TYPE != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_GXS_MSG_UPDATE != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsMsgUpdateItem* item = new RsGxsMsgUpdateItem(getRsItemService(rstype)); - - /* skip the header */ - offset += 8; - - ok &= item->peerID.deserialise(data, *size, offset) ; - uint32_t numUpdateItems; - ok &= getRawUInt32(data, *size, &offset, &(numUpdateItems)); - std::map& msgUpdateInfos = item->msgUpdateInfos; - RsGxsGroupId pId; - - RsGxsMsgUpdateItem::MsgUpdateInfo info ; - - for(uint32_t i = 0; i < numUpdateItems; i++) - { - ok &= pId.deserialise(data, *size, offset); - - if(!ok) - break; - - ok &= getRawUInt32(data, *size, &offset, &(info.time_stamp)); - ok &= getRawUInt32(data, *size, &offset, &(info.message_count)); - - if(!ok) - break; - - msgUpdateInfos.insert(std::make_pair(pId, info)); - } - - if (offset != rssize) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsMsgUpdate() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -RsGxsServerMsgUpdateItem* RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate(void* data, uint32_t* size) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (SERVICE_TYPE != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsServerMsgUpdateItem* item = new RsGxsServerMsgUpdateItem(getRsItemService(rstype)); - - /* skip the header */ - offset += 8; - - ok &= item->grpId.deserialise(data, *size, offset) ; - ok &= getRawUInt32(data, *size, &offset, &(item->msgUpdateTS)); - - if (offset != rssize) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - diff --git a/libretroshare/src/serialiser/rsgxsupdateitems.h b/libretroshare/src/serialiser/rsgxsupdateitems.h index 7d6c89907..8ea020fe5 100644 --- a/libretroshare/src/serialiser/rsgxsupdateitems.h +++ b/libretroshare/src/serialiser/rsgxsupdateitems.h @@ -55,15 +55,7 @@ public: RsGxsNetServiceItem(uint16_t serv_type,uint8_t subtype) : RsItem(RS_PKT_VERSION_SERVICE, serv_type, subtype) {} virtual ~RsGxsNetServiceItem() {} - - virtual bool serialise(void *data,uint32_t& size) const = 0 ; - virtual uint32_t serial_size() const = 0 ; - virtual void clear() = 0 ; - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0; - -protected: - bool serialise_header(void *data, uint32_t& pktsize, uint32_t& tlvsize, uint32_t& offset) const; }; class RsGxsGrpConfig @@ -96,10 +88,7 @@ public: virtual ~RsGxsGrpConfigItem() {} virtual void clear() {} - virtual std::ostream &print(std::ostream &out, uint16_t /*indent*/) { return out;} - - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsGxsGroupId grpId ; }; @@ -121,10 +110,7 @@ public: virtual ~RsGxsGrpUpdateItem() {} virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); - - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsPeerId peerID; }; @@ -145,11 +131,8 @@ public: virtual ~RsGxsServerGrpUpdateItem() {} - virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); - - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void clear(); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; class RsGxsMsgUpdate @@ -175,10 +158,7 @@ public: virtual ~RsGxsMsgUpdateItem() {} virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); - - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsPeerId peerID; }; @@ -199,58 +179,21 @@ public: virtual ~RsGxsServerMsgUpdateItem() {} virtual void clear(); - virtual std::ostream &print(std::ostream &out, uint16_t indent); - - virtual bool serialise(void *data,uint32_t& size) const ; - virtual uint32_t serial_size() const ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsGxsGroupId grpId; }; -class RsGxsUpdateSerialiser : public RsSerialType +class RsGxsUpdateSerialiser : public RsServiceSerializer { public: - RsGxsUpdateSerialiser(uint16_t servtype) : RsSerialType(RS_PKT_VERSION_SERVICE, servtype), SERVICE_TYPE(servtype) {} + RsGxsUpdateSerialiser(uint16_t servtype) : RsServiceSerializer(servtype), SERVICE_TYPE(servtype) {} virtual ~RsGxsUpdateSerialiser() {} - virtual uint32_t size(RsItem *item) - { - RsGxsNetServiceItem *gitem = dynamic_cast(item); - - if (!gitem) - { - std::cerr << "(EE) trying to serialise/size an item that is not a RsGxsNetServiceItem!" << std::endl; - return 0; - } - - return gitem->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - RsGxsNetServiceItem *gitem = dynamic_cast(item); - - if (!gitem) - { - std::cerr << "(EE) trying to serialise an item that is not a RsGxsNetServiceItem!" << std::endl; - return false; - } - - return gitem->serialise(data,*size) ; - } - - virtual RsItem* deserialise(void *data, uint32_t *size); - -private: - RsGxsGrpConfigItem *deserialGxsGrpConfig(void *data, uint32_t *size); - RsGxsServerMsgUpdateItem *deserialGxsServerMsgUpdate(void *data, uint32_t *size); - RsGxsMsgUpdateItem *deserialGxsMsgUpdate(void *data, uint32_t *size); - RsGxsServerGrpUpdateItem *deserialGxsServerGrpUpddate(void *data, uint32_t *size); - RsGxsGrpUpdateItem *deserialGxsGrpUpddate(void *data, uint32_t *size); - - bool checkItemHeader(void *data, uint32_t *size, uint16_t service_type,uint8_t subservice_type); + virtual RsItem* create_item(uint16_t service,uint8_t item_subtype) const ; const uint16_t SERVICE_TYPE; }; diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 3da545df8..3ed0e9c16 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -88,8 +88,8 @@ class RsTypeSerializer ctx.mOffset += 4 ; for(typename std::map::iterator it(v.begin());it!=v.end();++it) { - ctx.mOffset += serial_size(it->first) ; - ctx.mOffset += serial_size(it->second) ; + serial_process(j,ctx,const_cast(it->first),"map::*it->first") ; + serial_process(j,ctx,const_cast(it->second),"map::*it->second") ; } } break ; @@ -97,15 +97,15 @@ class RsTypeSerializer case RsGenericSerializer::DESERIALIZE: { uint32_t n=0 ; - ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; + serial_process(j,ctx,n,"temporary size"); for(uint32_t i=0;ifirst") ; + serial_process(j,ctx,u,"map::*it->second") ; v[t] = u ; } @@ -115,12 +115,12 @@ class RsTypeSerializer case RsGenericSerializer::SERIALIZE: { uint32_t n=v.size(); - ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; + serial_process(j,ctx,n,"temporary size"); for(typename std::map::iterator it(v.begin());it!=v.end();++it) { - ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,it->first) ; - ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,it->second) ; + serial_process(j,ctx,const_cast(it->first),"map::*it->first") ; + serial_process(j,ctx,const_cast(it->second),"map::*it->second") ; } } break ; @@ -136,8 +136,8 @@ class RsTypeSerializer { std::cerr << " " ; - print_data("first",it->first) ; - print_data("second",it->second) ; + serial_process(j,ctx,const_cast(it->first),"map::*it->first") ; + serial_process(j,ctx,const_cast(it->second),"map::*it->second") ; } } break; From 45eaf27deb3bcf51e6d722f432fffa8fca30fe36 Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 16:30:33 +0200 Subject: [PATCH 72/94] moved rsgxsupdateitems to rsitems/ --- libretroshare/src/gxs/rsgxsnetservice.h | 2 +- libretroshare/src/libretroshare.pro | 4 ++-- libretroshare/src/{serialiser => rsitems}/rsgxsupdateitems.cc | 2 +- libretroshare/src/{serialiser => rsitems}/rsgxsupdateitems.h | 0 4 files changed, 4 insertions(+), 4 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsgxsupdateitems.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rsgxsupdateitems.h (100%) diff --git a/libretroshare/src/gxs/rsgxsnetservice.h b/libretroshare/src/gxs/rsgxsnetservice.h index 883649e57..b74e53998 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.h +++ b/libretroshare/src/gxs/rsgxsnetservice.h @@ -34,7 +34,7 @@ #include "rsnxsobserver.h" #include "pqi/p3linkmgr.h" #include "rsitems/rsnxsitems.h" -#include "serialiser/rsgxsupdateitems.h" +#include "rsitems/rsgxsupdateitems.h" #include "rsgxsnetutils.h" #include "pqi/p3cfgmgr.h" #include "rsgixs.h" diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 455ad9d33..ca5a07442 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -486,7 +486,7 @@ HEADERS += rsitems/rsitem.h \ rsitems/rsheartbeatitems.h \ rsitems/rsrttitems.h \ serialiser/rsgxsrecognitems.h \ - serialiser/rsgxsupdateitems.h \ + rsitems/rsgxsupdateitems.h \ serialiser/rsserviceinfoitems.h \ HEADERS += services/p3msgservice.h \ @@ -632,7 +632,7 @@ SOURCES += serialiser/rsbaseserial.cc \ rsitems/rsdiscovery2items.cc \ rsitems/rsrttitems.cc \ serialiser/rsgxsrecognitems.cc \ - serialiser/rsgxsupdateitems.cc \ + rsitems/rsgxsupdateitems.cc \ serialiser/rsserviceinfoitems.cc \ SOURCES += services/p3msgservice.cc \ diff --git a/libretroshare/src/serialiser/rsgxsupdateitems.cc b/libretroshare/src/rsitems/rsgxsupdateitems.cc similarity index 99% rename from libretroshare/src/serialiser/rsgxsupdateitems.cc rename to libretroshare/src/rsitems/rsgxsupdateitems.cc index f0a7912b3..259cd1b4a 100644 --- a/libretroshare/src/serialiser/rsgxsupdateitems.cc +++ b/libretroshare/src/rsitems/rsgxsupdateitems.cc @@ -24,9 +24,9 @@ */ #include "serialization/rstypeserializer.h" +#include "serialiser/rsbaseserial.h" #include "rsgxsupdateitems.h" -#include "rsbaseserial.h" /**********************************************************************************************/ /* SERIALIZER */ diff --git a/libretroshare/src/serialiser/rsgxsupdateitems.h b/libretroshare/src/rsitems/rsgxsupdateitems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxsupdateitems.h rename to libretroshare/src/rsitems/rsgxsupdateitems.h From d32a8caf0650bb5686e35fea80983eec838acf81 Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 16:39:54 +0200 Subject: [PATCH 73/94] switched PluginItems to new serialization --- libretroshare/src/serialiser/rsphotoitems.h | 4 +- libretroshare/src/serialiser/rspluginitems.cc | 3 ++ libretroshare/src/serialiser/rspluginitems.h | 48 ++++++++----------- 3 files changed, 24 insertions(+), 31 deletions(-) diff --git a/libretroshare/src/serialiser/rsphotoitems.h b/libretroshare/src/serialiser/rsphotoitems.h index a935472e6..814ea52bc 100644 --- a/libretroshare/src/serialiser/rsphotoitems.h +++ b/libretroshare/src/serialiser/rsphotoitems.h @@ -34,8 +34,8 @@ #include "rsgxsitems.h" #include "retroshare/rsphoto.h" -const uint8_t RS_PKT_SUBTYPE_PHOTO_ITEM = 0x02; -const uint8_t RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM = 0x03; +const uint8_t RS_PKT_SUBTYPE_PHOTO_ITEM = 0x02; +const uint8_t RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM = 0x03; const uint8_t RS_PKT_SUBTYPE_PHOTO_COMMENT_ITEM = 0x04; class RsGxsPhotoAlbumItem : public RsGxsGrpItem diff --git a/libretroshare/src/serialiser/rspluginitems.cc b/libretroshare/src/serialiser/rspluginitems.cc index d671d1a1c..f09046d9f 100644 --- a/libretroshare/src/serialiser/rspluginitems.cc +++ b/libretroshare/src/serialiser/rspluginitems.cc @@ -1,5 +1,6 @@ #include "rspluginitems.h" +#ifdef TO_REMOVE #ifndef WINDOWS_SYS #include #endif @@ -130,3 +131,5 @@ std::ostream& RsPluginHashSetItem::print(std::ostream& o, uint16_t) } + +#endif diff --git a/libretroshare/src/serialiser/rspluginitems.h b/libretroshare/src/serialiser/rspluginitems.h index 02b64fc54..d21533c68 100644 --- a/libretroshare/src/serialiser/rspluginitems.h +++ b/libretroshare/src/serialiser/rspluginitems.h @@ -26,14 +26,10 @@ #pragma once -#include "serialiser/rsserial.h" +#include "rsitems/rsitem.h" #include "rsitems/rsconfigitems.h" -#include "serialiser/rsbaseserial.h" -#if 0 -#include "serialiser/rstlvbase.h" -#include "serialiser/rstlvtypes.h" -#endif +#include "serialization/rstypeserializer.h" const uint8_t RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET = 0x01 ; @@ -43,41 +39,35 @@ class RsPluginItem: public RsItem RsPluginItem(uint8_t plugin_item_subtype): RsItem(RS_PKT_VERSION1,RS_PKT_CLASS_CONFIG,RS_PKT_TYPE_PLUGIN_CONFIG,plugin_item_subtype) {} virtual ~RsPluginItem() {} - virtual bool serialise(void *data,uint32_t& size) = 0 ; // Isn't it better that items can serialise themselves ? - virtual uint32_t serial_size() = 0 ; // deserialise is handled using a constructor - virtual void clear() {} }; -class RsPluginSerialiser: public RsSerialType -{ - public: - RsPluginSerialiser() : RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PLUGIN_CONFIG) {} - - virtual uint32_t size (RsItem *item) - { - return dynamic_cast(item)->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - return dynamic_cast(item)->serialise(data,*size) ; - } - virtual RsItem *deserialise (void *data, uint32_t *size) ; -}; - class RsPluginHashSetItem: public RsPluginItem { public: RsPluginHashSetItem() : RsPluginItem(RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET) {} RsPluginHashSetItem(void *data,uint32_t size) ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) + { + RsTypeSerializer::serial_process(j,ctx,hashes,"hashes"); + } + RsTlvHashSet hashes ; +}; - virtual std::ostream& print(std::ostream& o, uint16_t) ; +class RsPluginSerialiser: public RsConfigSerializer +{ + public: + RsPluginSerialiser() : RsConfigSerializer(RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PLUGIN_CONFIG) {} - protected: - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() ; + virtual RsItem *create_item(uint8_t class_type, uint8_t item_type) const + { + if(class_type == RS_PKT_TYPE_PLUGIN_CONFIG && item_type == RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET) + return new RsPluginHashSetItem() ; + + return NULL ; + } }; From c33c34b17527081b15abcbd6d9622f4ccfa6643e Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 16:44:04 +0200 Subject: [PATCH 74/94] moved rspluginitems to rsitems/ --- libretroshare/src/libretroshare.pro | 5 +- libretroshare/src/plugins/pluginmanager.cc | 5 +- .../{serialiser => rsitems}/rspluginitems.h | 0 libretroshare/src/serialiser/rspluginitems.cc | 135 ------------------ 4 files changed, 4 insertions(+), 141 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rspluginitems.h (100%) delete mode 100644 libretroshare/src/serialiser/rspluginitems.cc diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index ca5a07442..2b7a1b96f 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -143,7 +143,7 @@ PUBLIC_HEADERS = retroshare/rsdisc.h \ HEADERS += plugins/pluginmanager.h \ plugins/dlfcn_win32.h \ - serialiser/rspluginitems.h \ + rsitems/rspluginitems.h \ util/rsinitedptr.h HEADERS += $$PUBLIC_HEADERS @@ -605,8 +605,7 @@ SOURCES += grouter/p3grouter.cc \ grouter/groutermatrix.cc SOURCES += plugins/pluginmanager.cc \ - plugins/dlfcn_win32.cc \ - serialiser/rspluginitems.cc + plugins/dlfcn_win32.cc SOURCES += serialiser/rsbaseserial.cc \ rsitems/rsfiletransferitems.cc \ diff --git a/libretroshare/src/plugins/pluginmanager.cc b/libretroshare/src/plugins/pluginmanager.cc index 431b6c2f8..bbc1761fb 100644 --- a/libretroshare/src/plugins/pluginmanager.cc +++ b/libretroshare/src/plugins/pluginmanager.cc @@ -9,8 +9,7 @@ #include #endif -#include - +#include #include #include @@ -34,7 +33,7 @@ std::string RsPluginManager::_plugin_entry_symbol = "RETROSHARE_PLUGIN_provide" ; std::string RsPluginManager::_plugin_revision_symbol = "RETROSHARE_PLUGIN_revision" ; -std::string RsPluginManager::_plugin_API_symbol = "RETROSHARE_PLUGIN_api" ; +std::string RsPluginManager::_plugin_API_symbol = "RETROSHARE_PLUGIN_api" ; std::string RsPluginManager::_local_cache_dir ; std::string RsPluginManager::_remote_cache_dir ; diff --git a/libretroshare/src/serialiser/rspluginitems.h b/libretroshare/src/rsitems/rspluginitems.h similarity index 100% rename from libretroshare/src/serialiser/rspluginitems.h rename to libretroshare/src/rsitems/rspluginitems.h diff --git a/libretroshare/src/serialiser/rspluginitems.cc b/libretroshare/src/serialiser/rspluginitems.cc deleted file mode 100644 index f09046d9f..000000000 --- a/libretroshare/src/serialiser/rspluginitems.cc +++ /dev/null @@ -1,135 +0,0 @@ -#include "rspluginitems.h" - -#ifdef TO_REMOVE -#ifndef WINDOWS_SYS -#include -#endif - -bool RsPluginHashSetItem::serialise(void *data,uint32_t& pktsize) -{ - uint32_t tlvsize = serial_size(); - uint32_t offset = 0; - -#ifdef P3TURTLE_DEBUG - std::cerr << "RsPluginSerialiser::serialising HashSet packet (size=" << tlvsize << ")" << std::endl; -#endif - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data,tlvsize,PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - - ok &= hashes.SetTlv(data,tlvsize,&offset) ; - - if (offset != tlvsize) - { - ok = false; -#ifdef P3TURTLE_DEBUG - std::cerr << "RsPluginHashSetItem::serialise() Size Error! (offset=" << offset << ", tlvsize=" << tlvsize << ")" << std::endl; -#endif - } - - return ok ; -} - -RsPluginHashSetItem::RsPluginHashSetItem(void *data,uint32_t size) - : RsPluginItem(RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - hashes.ids.clear() ; - - ok &= hashes.GetTlv(data,size,&offset) ; - - if (offset != rssize) - { -#ifdef TLV_DEBUG - std::cerr << "RsTlvPeerIdSet::GetTlv() Warning extra bytes at end of item"; - std::cerr << std::endl; -#endif - ok = false ; - } - -#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs). - UNREFERENCED_LOCAL_VARIABLE(rssize); -#else - if (!ok) - throw std::runtime_error("Unknown error while deserializing.") ; -#endif - -} - -RsItem *RsPluginSerialiser::deserialise(void *data, uint32_t *size) -{ - // look what we have... - - /* get the type */ - uint32_t rstype = getRsItemId(data); -#ifdef P3TURTLE_DEBUG - std::cerr << "p3turtle: deserialising packet: " << std::endl ; -#endif - if ( (RS_PKT_VERSION1 != getRsItemVersion(rstype)) - || (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) - || (RS_PKT_TYPE_PLUGIN_CONFIG != getRsItemType(rstype))) - { -#ifdef P3TURTLE_DEBUG - std::cerr << " Wrong type !!" << std::endl ; -#endif - return NULL; /* wrong type */ - } - -#ifndef WINDOWS_SYS - try - { -#endif - switch(getRsItemSubType(rstype)) - { - case RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET : return new RsPluginHashSetItem(data,*size) ; - - default: - std::cerr << "Unknown packet type in RsPluginSerialiser. Type = " << rstype << std::endl; - return NULL ; - } -#ifndef WINDOWS_SYS - } - catch(std::exception& e) - { - std::cerr << "Exception raised: " << e.what() << std::endl ; - return NULL ; - } -#endif -} - -uint32_t RsPluginHashSetItem::serial_size() -{ - uint32_t size = 8 ; - - size += hashes.TlvSize() ; - - return size ; -} - -std::ostream& RsPluginHashSetItem::print(std::ostream& o, uint16_t) -{ - o << "Item type: RsPluginHashSetItem" << std::endl; - o << " Hash list: " << std::endl; - - for(std::set::const_iterator it(hashes.ids.begin());it!=hashes.ids.end();++it) - o << " " << *it << std::endl; - - return o ; -} - - - -#endif From 2d19783296276c1e99f14c420f1c6af97050c403 Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 17:44:45 +0200 Subject: [PATCH 75/94] switched serviceinfo items to new serialization --- .../src/serialiser/rsserviceinfoitems.cc | 51 +++++++++-------- .../src/serialiser/rsserviceinfoitems.h | 57 +++++-------------- .../src/serialiser/rstlvgenericmap.inl | 1 + 3 files changed, 43 insertions(+), 66 deletions(-) diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.cc b/libretroshare/src/serialiser/rsserviceinfoitems.cc index 8efc0eb87..a538273de 100644 --- a/libretroshare/src/serialiser/rsserviceinfoitems.cc +++ b/libretroshare/src/serialiser/rsserviceinfoitems.cc @@ -25,6 +25,7 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rsserviceinfoitems.h" +#include "serialization/rstypeserializer.h" /*** #define RSSERIAL_DEBUG 1 @@ -35,8 +36,7 @@ /*************************************************************************/ /***** RsServiceInfo ****/ -template<> -std::ostream &RsTlvParamRef::print(std::ostream &out, uint16_t /*indent*/) const +template<> std::ostream& RsTlvParamRef::print(std::ostream &out, uint16_t /*indent*/) const { out << "RsServiceInfo: " << mParam.mServiceType << " name " << mParam.mServiceName; out << std::endl; @@ -138,38 +138,19 @@ template class RsTlvParamRef; /*************************************************************************/ -RsServiceInfoListItem::~RsServiceInfoListItem() -{ - return; -} - void RsServiceInfoListItem::clear() { mServiceInfo.clear(); } -std::ostream &RsServiceInfoListItem::print(std::ostream &out, uint16_t indent) +void RsServiceInfoListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - printRsItemBase(out, "RsServiceInfoListItem", indent); - uint16_t int_Indent = indent + 2; RsTlvServiceInfoMapRef map(mServiceInfo); - map.print(out, int_Indent); - out << std::endl; - printRsItemEnd(out, "RsServiceInfoListItem", indent); - return out; -} - - -uint32_t RsServiceInfoSerialiser::sizeInfo(RsServiceInfoListItem *item) -{ - uint32_t s = 8; /* header */ - RsTlvServiceInfoMapRef map(item->mServiceInfo); - s += map.TlvSize(); - - return s; + RsTypeSerializer::serial_process(j,ctx,map,"map") ; } +#ifdef TO_REMOVE /* serialise the data to the buffer */ bool RsServiceInfoSerialiser::serialiseInfo(RsServiceInfoListItem *item, void *data, uint32_t *pktsize) { @@ -291,7 +272,14 @@ uint32_t RsServiceInfoSerialiser::sizePermissions(RsServiceInfoPermissionsIte return s; } +#endif +void RsServiceInfoPermissionsItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,allowedBw,"allowedBw") ; +} + +#ifdef TO_REMOVE /* serialise the data to the buffer */ bool RsServiceInfoSerialiser::serialisePermissions(RsServiceInfoPermissionsItem *item, void *data, uint32_t *pktsize) { @@ -440,6 +428,21 @@ RsItem *RsServiceInfoSerialiser::deserialise(void *data, uint32_t *pktsize) } /*************************************************************************/ +#endif + +RsItem *RsServiceInfoSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const +{ + if(service != RS_SERVICE_TYPE_SERVICEINFO) + return NULL ; + + switch(item_sub_id) + { + case RS_PKT_SUBTYPE_SERVICELIST_ITEM: return new RsServiceInfoListItem() ; + case RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM: return new RsServiceInfoPermissionsItem() ; + default: + return NULL ; + } +} diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.h b/libretroshare/src/serialiser/rsserviceinfoitems.h index b4c9beabe..04a524331 100644 --- a/libretroshare/src/serialiser/rsserviceinfoitems.h +++ b/libretroshare/src/serialiser/rsserviceinfoitems.h @@ -34,8 +34,6 @@ #include "rsitems/rsitem.h" #include "rsitems/itempriorities.h" -#include "serialiser/rsserial.h" -#include "serialiser/rstlvbase.h" #include "serialiser/rstlvgenericmap.h" #include "retroshare/rsservicecontrol.h" @@ -63,72 +61,47 @@ public: } }; - - class RsServiceInfoListItem: public RsItem { public: - RsServiceInfoListItem() - :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICEINFO, - RS_PKT_SUBTYPE_SERVICELIST_ITEM) + RsServiceInfoListItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICEINFO, RS_PKT_SUBTYPE_SERVICELIST_ITEM) { setPriorityLevel(QOS_PRIORITY_RS_SERVICE_INFO_ITEM); return; } -virtual ~RsServiceInfoListItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual ~RsServiceInfoListItem(){} + virtual void clear(); - std::map mServiceInfo; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + std::map mServiceInfo; }; - class RsServiceInfoPermissionsItem: public RsItem { public: - RsServiceInfoPermissionsItem() - :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICEINFO, - RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM) + RsServiceInfoPermissionsItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICEINFO, RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM) { setPriorityLevel(QOS_PRIORITY_RS_SERVICE_INFO_ITEM); return; } -virtual ~RsServiceInfoPermissionsItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual ~RsServiceInfoPermissionsItem(){} + virtual void clear(){} + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t allowedBw; // Units are bytes/sec => 4Gb/s; - }; - -class RsServiceInfoSerialiser: public RsSerialType +class RsServiceInfoSerialiser: public RsServiceSerializer { public: - RsServiceInfoSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICEINFO) - { return; } -virtual ~RsServiceInfoSerialiser() - { return; } + RsServiceInfoSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_SERVICEINFO) {} + virtual ~RsServiceInfoSerialiser() {} -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - -virtual uint32_t sizeInfo(RsServiceInfoListItem *); -virtual bool serialiseInfo(RsServiceInfoListItem *item, void *data, uint32_t *size); -virtual RsServiceInfoListItem *deserialiseInfo(void *data, uint32_t *size); - - -virtual uint32_t sizePermissions(RsServiceInfoPermissionsItem *); -virtual bool serialisePermissions(RsServiceInfoPermissionsItem *item, void *data, uint32_t *size); -virtual RsServiceInfoPermissionsItem *deserialisePermissions(void *data, uint32_t *size); - - + virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const; }; /**************************************************************************/ diff --git a/libretroshare/src/serialiser/rstlvgenericmap.inl b/libretroshare/src/serialiser/rstlvgenericmap.inl index 87e0d8b04..540ee5d2e 100644 --- a/libretroshare/src/serialiser/rstlvgenericmap.inl +++ b/libretroshare/src/serialiser/rstlvgenericmap.inl @@ -24,6 +24,7 @@ * */ +#include "serialiser/rstlvbase.h" // Must be different - as this is inline in headers. //#define TLV_GENERICMAP_DEBUG 1 From 22e2416f3ea50460a9f944a14ac1e2b5b29f8be3 Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 17:47:41 +0200 Subject: [PATCH 76/94] moved rsserviceinfo items to rsitems/ --- libretroshare/src/libretroshare.pro | 4 ++-- .../src/{serialiser => rsitems}/rsserviceinfoitems.cc | 2 +- .../src/{serialiser => rsitems}/rsserviceinfoitems.h | 0 libretroshare/src/services/p3serviceinfo.h | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsserviceinfoitems.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rsserviceinfoitems.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 2b7a1b96f..a72b2d246 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -487,7 +487,7 @@ HEADERS += rsitems/rsitem.h \ rsitems/rsrttitems.h \ serialiser/rsgxsrecognitems.h \ rsitems/rsgxsupdateitems.h \ - serialiser/rsserviceinfoitems.h \ + rsitems/rsserviceinfoitems.h \ HEADERS += services/p3msgservice.h \ services/p3service.h \ @@ -632,7 +632,7 @@ SOURCES += serialiser/rsbaseserial.cc \ rsitems/rsrttitems.cc \ serialiser/rsgxsrecognitems.cc \ rsitems/rsgxsupdateitems.cc \ - serialiser/rsserviceinfoitems.cc \ + rsitems/rsserviceinfoitems.cc \ SOURCES += services/p3msgservice.cc \ services/p3service.cc \ diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.cc b/libretroshare/src/rsitems/rsserviceinfoitems.cc similarity index 99% rename from libretroshare/src/serialiser/rsserviceinfoitems.cc rename to libretroshare/src/rsitems/rsserviceinfoitems.cc index a538273de..e09160db8 100644 --- a/libretroshare/src/serialiser/rsserviceinfoitems.cc +++ b/libretroshare/src/rsitems/rsserviceinfoitems.cc @@ -24,8 +24,8 @@ */ #include "serialiser/rsbaseserial.h" -#include "serialiser/rsserviceinfoitems.h" #include "serialization/rstypeserializer.h" +#include "rsitems/rsserviceinfoitems.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.h b/libretroshare/src/rsitems/rsserviceinfoitems.h similarity index 100% rename from libretroshare/src/serialiser/rsserviceinfoitems.h rename to libretroshare/src/rsitems/rsserviceinfoitems.h diff --git a/libretroshare/src/services/p3serviceinfo.h b/libretroshare/src/services/p3serviceinfo.h index 4d776e44e..210731af1 100644 --- a/libretroshare/src/services/p3serviceinfo.h +++ b/libretroshare/src/services/p3serviceinfo.h @@ -36,7 +36,7 @@ #include "services/p3service.h" -#include "serialiser/rsserviceinfoitems.h" +#include "rsitems/rsserviceinfoitems.h" //!The ServiceInfo service. /** From d3c960e4e7a97d2b21188bee462573249988bd8f Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 17:48:54 +0200 Subject: [PATCH 77/94] removed old code --- .../src/rsitems/rsserviceinfoitems.cc | 345 ++---------------- 1 file changed, 35 insertions(+), 310 deletions(-) diff --git a/libretroshare/src/rsitems/rsserviceinfoitems.cc b/libretroshare/src/rsitems/rsserviceinfoitems.cc index e09160db8..35ba6d02d 100644 --- a/libretroshare/src/rsitems/rsserviceinfoitems.cc +++ b/libretroshare/src/rsitems/rsserviceinfoitems.cc @@ -35,6 +35,41 @@ /*************************************************************************/ /***** RsServiceInfo ****/ +/*************************************************************************/ + +void RsServiceInfoListItem::clear() +{ + mServiceInfo.clear(); +} + +void RsServiceInfoListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTlvServiceInfoMapRef map(mServiceInfo); + + RsTypeSerializer::serial_process(j,ctx,map,"map") ; +} + +void RsServiceInfoPermissionsItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,allowedBw,"allowedBw") ; +} + +RsItem *RsServiceInfoSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const +{ + if(service != RS_SERVICE_TYPE_SERVICEINFO) + return NULL ; + + switch(item_sub_id) + { + case RS_PKT_SUBTYPE_SERVICELIST_ITEM: return new RsServiceInfoListItem() ; + case RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM: return new RsServiceInfoPermissionsItem() ; + default: + return NULL ; + } +} + + + template<> std::ostream& RsTlvParamRef::print(std::ostream &out, uint16_t /*indent*/) const { @@ -136,313 +171,3 @@ bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *o template class RsTlvParamRef; -/*************************************************************************/ - -void RsServiceInfoListItem::clear() -{ - mServiceInfo.clear(); -} - -void RsServiceInfoListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) -{ - RsTlvServiceInfoMapRef map(mServiceInfo); - - RsTypeSerializer::serial_process(j,ctx,map,"map") ; -} - -#ifdef TO_REMOVE -/* serialise the data to the buffer */ -bool RsServiceInfoSerialiser::serialiseInfo(RsServiceInfoListItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeInfo(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsServiceInfoSerialiser::serialiseInfo() Header: " << ok << std::endl; - std::cerr << "RsServiceInfoSerialiser::serialiseInfo() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - RsTlvServiceInfoMapRef map(item->mServiceInfo); - ok &= map.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsServiceInfoSerialiser::serialiseInfo() Size Error! " << std::endl; -#endif - } - return ok; -} - -RsServiceInfoListItem *RsServiceInfoSerialiser::deserialiseInfo(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t tlvsize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_SERVICEINFO != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_SERVICELIST_ITEM != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < tlvsize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = tlvsize; - - bool ok = true; - - /* ready to load */ - RsServiceInfoListItem *item = new RsServiceInfoListItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - RsTlvServiceInfoMapRef map(item->mServiceInfo); - ok &= map.GetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ -/*************************************************************************/ - -RsServiceInfoPermissionsItem::~RsServiceInfoPermissionsItem() -{ - return; -} - -void RsServiceInfoPermissionsItem::clear() -{ - allowedBw = 0; -} - -std::ostream &RsServiceInfoPermissionsItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsServiceInfoPermissionsItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "AllowedBw: " << allowedBw; - out << std::endl; - - printRsItemEnd(out, "RsServiceInfoPermissionsItem", indent); - return out; -} - - -uint32_t RsServiceInfoSerialiser::sizePermissions(RsServiceInfoPermissionsItem * /*item*/) -{ - uint32_t s = 8; /* header */ - s += GetTlvUInt32Size(); - - return s; -} -#endif - -void RsServiceInfoPermissionsItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) -{ - RsTypeSerializer::serial_process(j,ctx,allowedBw,"allowedBw") ; -} - -#ifdef TO_REMOVE -/* serialise the data to the buffer */ -bool RsServiceInfoSerialiser::serialisePermissions(RsServiceInfoPermissionsItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizePermissions(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsServiceInfoSerialiser::serialisePermissions() Header: " << ok << std::endl; - std::cerr << "RsServiceInfoSerialiser::serialisePermissions() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= SetTlvUInt32(data, tlvsize, &offset, TLV_TYPE_UINT32_BW, item->allowedBw); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsServiceInfoSerialiser::serialisePermissions() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsServiceInfoPermissionsItem *RsServiceInfoSerialiser::deserialisePermissions(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t tlvsize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_SERVICEINFO != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < tlvsize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = tlvsize; - - bool ok = true; - - /* ready to load */ - RsServiceInfoPermissionsItem *item = new RsServiceInfoPermissionsItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= GetTlvUInt32(data, tlvsize, &offset, TLV_TYPE_UINT32_BW, &(item->allowedBw)); - - - if (offset != tlvsize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ - -uint32_t RsServiceInfoSerialiser::size(RsItem *i) -{ - RsServiceInfoListItem *sli; - RsServiceInfoPermissionsItem *spi; - - if (NULL != (sli = dynamic_cast(i))) - { - return sizeInfo(sli); - } - if (NULL != (spi = dynamic_cast(i))) - { - return sizePermissions(spi); - } - return 0; -} - -bool RsServiceInfoSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsServiceInfoListItem *sli; - RsServiceInfoPermissionsItem *spi; - - if (NULL != (sli = dynamic_cast(i))) - { - return serialiseInfo(sli, data, pktsize); - } - if (NULL != (spi = dynamic_cast(i))) - { - return serialisePermissions(spi, data, pktsize); - } - return false; -} - -RsItem *RsServiceInfoSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_SERVICEINFO != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_SERVICELIST_ITEM: - return deserialiseInfo(data, pktsize); - break; - case RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM: - return deserialisePermissions(data, pktsize); - break; - default: - return NULL; - break; - } -} - -/*************************************************************************/ -#endif - -RsItem *RsServiceInfoSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const -{ - if(service != RS_SERVICE_TYPE_SERVICEINFO) - return NULL ; - - switch(item_sub_id) - { - case RS_PKT_SUBTYPE_SERVICELIST_ITEM: return new RsServiceInfoListItem() ; - case RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM: return new RsServiceInfoPermissionsItem() ; - default: - return NULL ; - } -} - - - From 634efb6142d7ccb14a13178a9e03d61cc89a56bb Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 18:42:11 +0200 Subject: [PATCH 78/94] switched rsphotoitems to new serialization --- .../src/retroshare/rsgxsifacetypes.h | 1 + libretroshare/src/serialiser/rsphotoitems.cc | 87 ++++++++++++++++--- libretroshare/src/serialiser/rsphotoitems.h | 56 +++++------- libretroshare/src/serialiser/rstlvbinary.cc | 84 ++++++++++++++++++ libretroshare/src/serialiser/rstlvbinary.h | 19 ++++ 5 files changed, 200 insertions(+), 47 deletions(-) diff --git a/libretroshare/src/retroshare/rsgxsifacetypes.h b/libretroshare/src/retroshare/rsgxsifacetypes.h index 6fd907898..0b1682327 100644 --- a/libretroshare/src/retroshare/rsgxsifacetypes.h +++ b/libretroshare/src/retroshare/rsgxsifacetypes.h @@ -14,6 +14,7 @@ #include #include +#include typedef GXSGroupId RsGxsGroupId; typedef Sha1CheckSum RsGxsMessageId; diff --git a/libretroshare/src/serialiser/rsphotoitems.cc b/libretroshare/src/serialiser/rsphotoitems.cc index 3ff10cf8e..6971793d1 100644 --- a/libretroshare/src/serialiser/rsphotoitems.cc +++ b/libretroshare/src/serialiser/rsphotoitems.cc @@ -33,6 +33,22 @@ #define GXS_PHOTO_SERIAL_DEBUG +virtual RsItem *create_item(uint16_t service, uint8_t item_sub_id) const +{ + if(service != RS_SERVICE_GXS_TYPE_PHOTO) + return NULL ; + + switch(item_sub_id) + { + case RS_PKT_SUBTYPE_PHOTO_COMMENT_ITEM: return new RsGxsPhotoCommentItem() ; + case RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM: return new RsGxsPhotoAlbumItem() ; + case RS_PKT_SUBTYPE_PHOTO_ITEM: return new RsGxsPhotoPhotoItem() ; + default: + return NULL ; + } +} + +#ifdef TO_REMOVE uint32_t RsGxsPhotoSerialiser::size(RsItem* item) { RsGxsPhotoPhotoItem* ppItem = NULL; @@ -161,7 +177,27 @@ uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoCommentItem(RsGxsPhotoCommentItem return s; } +#endif +void RsGxsPhotoAlbumItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_CAPTION, album.mCaption, "mCaption"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_CATEGORY, album.mCategory, "mCategory"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR, album.mDescription, "mDescription"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_TAG, album.mHashTags, "mHashTags"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG, album.mOther, "mOther"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_PATH, album.mPhotoPath, "mPhotoPath"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_NAME, album.mPhotographer, "mPhotographer"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DATE, album.mWhen, "mWhen"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_LOCATION, album.mWhere, "mWhere"); + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_PIC_TYPE, album.mThumbnail.type,"mThumbnail.type"); + + RsTlvBinaryDataRef b(RS_SERVICE_GXS_TYPE_PHOTO, album.mThumbnail.data,album.mThumbnail.size); + + RsTypeSerializer::serial_process(j,ctx,b,"thumbnail binary data") ; +} + +#ifdef TO_REMOVE bool RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem(RsGxsPhotoAlbumItem* item, void* data, uint32_t* size) { @@ -326,7 +362,25 @@ uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoPhotoItem(RsGxsPhotoPhotoItem* item) return s; } +#endif +void RsGxsPhotoPhotoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_CAPTION, photo.mCaption); + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_CATEGORY, photo.mCategory); + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_DESCR, photo.mDescription); + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_HASH_TAG, photo.mHashTags); + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_MSG, photo.mOther); + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_PIC_AUTH, photo.mPhotographer); + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_DATE, photo.mWhen); + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_LOCATION, photo.mWhere); + RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_PIC_TYPE, photo.mThumbnail.type); + + RsTlvBinaryDataRef b(RS_SERVICE_GXS_TYPE_PHOTO,photo.mThumbnail.data, photo.mThumbnail.size); + RsTypeSerializer::serial_process(j,ctx, b, "mThumbnail") ; +} + +#ifdef TO_REMOVE bool RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem(RsGxsPhotoPhotoItem* item, void* data, uint32_t* size) { @@ -468,8 +522,15 @@ RsGxsPhotoPhotoItem* RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem(void* da return item; } +#endif +void RsGxsPhotoCommentItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_COMMENT,comment.mComment,"mComment"); + RsTypeSerializer::serial_process(j,ctx,comment.mCommentFlag,"mCommentFlag"); +} +#ifdef TO_REMOVE bool RsGxsPhotoSerialiser::serialiseGxsPhotoCommentItem (RsGxsPhotoCommentItem *item, void *data, uint32_t *size) { @@ -586,6 +647,7 @@ RsGxsPhotoCommentItem * RsGxsPhotoSerialiser::deserialiseGxsPhotoCommentItem( return item; } +#endif void RsGxsPhotoAlbumItem::clear() { @@ -607,6 +669,7 @@ void RsGxsPhotoCommentItem::clear() comment.mCommentFlag = 0; } +#ifdef TO_REMOVE std::ostream& RsGxsPhotoCommentItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsPhotoCommentItem", indent); @@ -628,6 +691,19 @@ std::ostream& RsGxsPhotoAlbumItem::print(std::ostream& out, uint16_t indent) return out; } +std::ostream& RsGxsPhotoPhotoItem::print(std::ostream& out, uint16_t indent) +{ + printRsItemBase(out, "RsGxsPhotoPhotoItem", indent); + uint16_t int_Indent = indent + 2; + + + printRsItemEnd(out ,"RsGxsPhotoPhotoItem", indent); + return out; +} + + +#endif + void RsGxsPhotoPhotoItem::clear() { photo.mCaption.clear(); @@ -640,14 +716,3 @@ void RsGxsPhotoPhotoItem::clear() photo.mWhere.clear(); photo.mThumbnail.deleteImage(); } - -std::ostream& RsGxsPhotoPhotoItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsPhotoPhotoItem", indent); - uint16_t int_Indent = indent + 2; - - - printRsItemEnd(out ,"RsGxsPhotoPhotoItem", indent); - return out; -} - diff --git a/libretroshare/src/serialiser/rsphotoitems.h b/libretroshare/src/serialiser/rsphotoitems.h index 814ea52bc..cbaf29700 100644 --- a/libretroshare/src/serialiser/rsphotoitems.h +++ b/libretroshare/src/serialiser/rsphotoitems.h @@ -29,9 +29,11 @@ #include #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" +#include "rsitems/rsgxsitems.h" + +#include "serialiser/rsserial.h" +#include "serialization/rsserializer.h" -#include "rsgxsitems.h" #include "retroshare/rsphoto.h" const uint8_t RS_PKT_SUBTYPE_PHOTO_ITEM = 0x02; @@ -50,6 +52,7 @@ public: void clear(); std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsPhotoAlbum album; }; @@ -58,11 +61,12 @@ class RsGxsPhotoPhotoItem : public RsGxsMsgItem { public: - RsGxsPhotoPhotoItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_PHOTO, - RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM) {return; } - virtual ~RsGxsPhotoPhotoItem() { return;} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsPhotoPhotoItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_PHOTO, RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM) {} + virtual ~RsGxsPhotoPhotoItem() {} + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + RsPhotoPhoto photo; }; @@ -70,43 +74,23 @@ class RsGxsPhotoCommentItem : public RsGxsMsgItem { public: - RsGxsPhotoCommentItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_PHOTO, - RS_PKT_SUBTYPE_PHOTO_COMMENT_ITEM) { return; } - virtual ~RsGxsPhotoCommentItem() { return; } + RsGxsPhotoCommentItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_PHOTO, RS_PKT_SUBTYPE_PHOTO_COMMENT_ITEM) {} + virtual ~RsGxsPhotoCommentItem() {} void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + RsPhotoComment comment; - - }; -class RsGxsPhotoSerialiser : public RsSerialType +class RsGxsPhotoSerialiser : public RsServiceSerializer { public: - RsGxsPhotoSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_PHOTO) - { return; } - virtual ~RsGxsPhotoSerialiser() { return; } - - uint32_t size(RsItem *item); - bool serialise (RsItem *item, void *data, uint32_t *size); - RsItem * deserialise(void *data, uint32_t *size); - - private: - - uint32_t sizeGxsPhotoAlbumItem(RsGxsPhotoAlbumItem *item); - bool serialiseGxsPhotoAlbumItem (RsGxsPhotoAlbumItem *item, void *data, uint32_t *size); - RsGxsPhotoAlbumItem * deserialiseGxsPhotoAlbumItem(void *data, uint32_t *size); - - uint32_t sizeGxsPhotoPhotoItem(RsGxsPhotoPhotoItem *item); - bool serialiseGxsPhotoPhotoItem (RsGxsPhotoPhotoItem *item, void *data, uint32_t *size); - RsGxsPhotoPhotoItem * deserialiseGxsPhotoPhotoItem(void *data, uint32_t *size); - - uint32_t sizeGxsPhotoCommentItem(RsGxsPhotoCommentItem *item); - bool serialiseGxsPhotoCommentItem (RsGxsPhotoCommentItem *item, void *data, uint32_t *size); - RsGxsPhotoCommentItem * deserialiseGxsPhotoCommentItem(void *data, uint32_t *size); + RsGxsPhotoSerialiser() :RsServiceSerializer(RS_SERVICE_GXS_TYPE_PHOTO) {} + virtual ~RsGxsPhotoSerialiser() {} + virtual RsItem *create_item(uint16_t service, uint8_t item_sub_id) const; }; #endif /* RSPHOTOV2ITEMS_H_ */ diff --git a/libretroshare/src/serialiser/rstlvbinary.cc b/libretroshare/src/serialiser/rstlvbinary.cc index 5b601a234..258da0d9a 100644 --- a/libretroshare/src/serialiser/rstlvbinary.cc +++ b/libretroshare/src/serialiser/rstlvbinary.cc @@ -218,5 +218,89 @@ std::ostream &RsTlvBinaryData::print(std::ostream &out, uint16_t indent) const } +bool RsTlvBinaryDataRef::SetTlv(void *data, uint32_t size, uint32_t *offset) const +{ + /* must check sizes */ + uint32_t tlvsize = TlvSize(); + uint32_t tlvend = *offset + tlvsize; + if (size < tlvend) + return false; /* not enough space */ + bool ok = true; + + /* start at data[offset] */ + ok &= SetTlvBase(data, tlvend, offset, tlvtype, tlvsize); + + /* add mandatory data */ + + // Warning: this is actually not an error if bin_len=0, as it does not + // corrupt the packet structure. We thus still return true in this case. + // + if (mDataRef != NULL && mSizeRef > 0) + { + memcpy(&(((uint8_t *) data)[*offset]), mDataRef, mSizeRef); + *offset += mSizeRef; + } + return ok; +} +bool RsTlvBinaryDataRef::GetTlv(void *data, uint32_t size, uint32_t *offset) +{ + if (size < *offset + TLV_HEADER_SIZE) + { + return false; /* not enough space to get the header */ + } + + uint16_t tlvtype_in = GetTlvType( &(((uint8_t *) data)[*offset]) ); + uint32_t tlvsize = GetTlvSize( &(((uint8_t *) data)[*offset]) ); + uint32_t tlvend = *offset + tlvsize; + + if (size < tlvend) /* check size */ + return false; /* not enough space */ + + if (tlvsize < TLV_HEADER_SIZE) + return false; /* bad tlv size */ + + if (tlvtype != tlvtype_in) /* check type */ + return false; + + /* skip the header */ + (*offset) += TLV_HEADER_SIZE; + + mDataRef = (uint8_t*)rs_malloc(tlvsize - TLV_HEADER_SIZE) ; + + if(mDataRef == NULL) + return false ; + + mSizeRef = tlvsize - TLV_HEADER_SIZE; + + memcpy(mDataRef,&(((uint8_t *) data)[*offset]), tlvsize - TLV_HEADER_SIZE); + *offset += mSizeRef; + + /*************************************************************************** + * NB: extra components could be added (for future expansion of the type). + * or be present (if this code is reading an extended version). + * + * We must chew up the extra characters to conform with TLV specifications + ***************************************************************************/ + if (*offset != tlvend) + { +#ifdef TLV_DEBUG + std::cerr << "RsTlvBinaryData::GetTlv() Warning extra bytes at end of item"; + std::cerr << std::endl; +#endif + *offset = tlvend; + } + + return true; +} + +uint32_t RsTlvBinaryDataRef::TlvSize() const +{ + uint32_t s = TLV_HEADER_SIZE; /* header */ + + if (mDataRef != NULL) + s += mSizeRef; // len is the size of data + + return s; +} diff --git a/libretroshare/src/serialiser/rstlvbinary.h b/libretroshare/src/serialiser/rstlvbinary.h index addac7f46..49a5d00f3 100644 --- a/libretroshare/src/serialiser/rstlvbinary.h +++ b/libretroshare/src/serialiser/rstlvbinary.h @@ -64,4 +64,23 @@ public: void *bin_data; /// mandatory }; +// This class is mainly used for on-the-fly serialization + +class RsTlvBinaryDataRef: public RsTlvItem +{ +public: + RsTlvBinaryDataRef(uint16_t type,uint8_t *& data_ref,uint32_t& size_ref) : mDataRef(data_ref),mSizeRef(size_ref),tlvtype(type) {} + virtual ~RsTlvBinaryDataRef() {} + + virtual uint32_t TlvSize() const; + virtual void TlvClear(){} + virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset) const; + virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); + + uint8_t *& mDataRef ; + uint32_t & mSizeRef ; + uint16_t tlvtype ; +}; + + From 688813fbf58a22bee997a09c2a9146a045803ec1 Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 18:51:35 +0200 Subject: [PATCH 79/94] moved photo items to rsitems/ --- libretroshare/src/libretroshare.pro | 4 +-- libretroshare/src/retroshare/rsphoto.h | 2 +- .../{serialiser => rsitems}/rsphotoitems.cc | 8 +++--- .../{serialiser => rsitems}/rsphotoitems.h | 0 libretroshare/src/serialiser/rstlvbinary.cc | 28 +++++++++++++++++++ libretroshare/src/serialiser/rstlvbinary.h | 2 ++ libretroshare/src/services/p3photoservice.cc | 2 +- 7 files changed, 38 insertions(+), 8 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsphotoitems.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rsphotoitems.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index a72b2d246..60fad8f7b 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -851,10 +851,10 @@ gxsphotoshare { #Photo Service HEADERS += services/p3photoservice.h \ retroshare/rsphoto.h \ - serialiser/rsphotoitems.h \ + rsitems/rsphotoitems.h \ SOURCES += services/p3photoservice.cc \ - serialiser/rsphotoitems.cc \ + rsitems/rsphotoitems.cc \ } diff --git a/libretroshare/src/retroshare/rsphoto.h b/libretroshare/src/retroshare/rsphoto.h index 7d3c1ae09..5a27a491b 100644 --- a/libretroshare/src/retroshare/rsphoto.h +++ b/libretroshare/src/retroshare/rsphoto.h @@ -52,7 +52,7 @@ class RsPhotoThumbnail // Holds Thumbnail image. uint8_t *data; - int size; + uint32_t size; std::string type; }; diff --git a/libretroshare/src/serialiser/rsphotoitems.cc b/libretroshare/src/rsitems/rsphotoitems.cc similarity index 99% rename from libretroshare/src/serialiser/rsphotoitems.cc rename to libretroshare/src/rsitems/rsphotoitems.cc index 6971793d1..e2f3c279a 100644 --- a/libretroshare/src/serialiser/rsphotoitems.cc +++ b/libretroshare/src/rsitems/rsphotoitems.cc @@ -25,15 +25,15 @@ #include -#include "serialiser/rsphotoitems.h" -#include "serialiser/rstlvbase.h" +#include "rsitems/rsphotoitems.h" + #include "serialiser/rstlvbinary.h" -#include "serialiser/rsbaseserial.h" +#include "serialization/rstypeserializer.h" #define GXS_PHOTO_SERIAL_DEBUG -virtual RsItem *create_item(uint16_t service, uint8_t item_sub_id) const +RsItem *RsGxsPhotoSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const { if(service != RS_SERVICE_GXS_TYPE_PHOTO) return NULL ; diff --git a/libretroshare/src/serialiser/rsphotoitems.h b/libretroshare/src/rsitems/rsphotoitems.h similarity index 100% rename from libretroshare/src/serialiser/rsphotoitems.h rename to libretroshare/src/rsitems/rsphotoitems.h diff --git a/libretroshare/src/serialiser/rstlvbinary.cc b/libretroshare/src/serialiser/rstlvbinary.cc index 258da0d9a..7eaa58ae2 100644 --- a/libretroshare/src/serialiser/rstlvbinary.cc +++ b/libretroshare/src/serialiser/rstlvbinary.cc @@ -188,6 +188,34 @@ bool RsTlvBinaryData::GetTlv(void *data, uint32_t size, uint32_t *offset) return ok; } +std::ostream &RsTlvBinaryDataRef::print(std::ostream &out, uint16_t indent) const +{ + uint16_t int_Indent = indent + 2; + + uint32_t i; + std::ostringstream sout; + printIndent(sout, indent); + sout << "RsTlvBinaryData: Type: " << tlvtype << " Size: " << mSizeRef; + sout << std::hex; + + for(i = 0; i < mSizeRef; i++) + { + if (i % 16 == 0) + { + sout << std::endl; + printIndent(sout, int_Indent); + } + sout << std::setw(2) << std::setfill('0') + << (int) (((unsigned char *) mDataRef)[i]) << ":"; + } + + sout << std::endl; + out << sout.str(); + + printEnd(out, "RsTlvBinaryData", indent); + return out; + +} std::ostream &RsTlvBinaryData::print(std::ostream &out, uint16_t indent) const { diff --git a/libretroshare/src/serialiser/rstlvbinary.h b/libretroshare/src/serialiser/rstlvbinary.h index 49a5d00f3..a22269e0f 100644 --- a/libretroshare/src/serialiser/rstlvbinary.h +++ b/libretroshare/src/serialiser/rstlvbinary.h @@ -72,6 +72,8 @@ public: RsTlvBinaryDataRef(uint16_t type,uint8_t *& data_ref,uint32_t& size_ref) : mDataRef(data_ref),mSizeRef(size_ref),tlvtype(type) {} virtual ~RsTlvBinaryDataRef() {} + virtual std::ostream &print(std::ostream &out, uint16_t indent) const; + virtual uint32_t TlvSize() const; virtual void TlvClear(){} virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset) const; diff --git a/libretroshare/src/services/p3photoservice.cc b/libretroshare/src/services/p3photoservice.cc index 759f5ad18..519f10c68 100644 --- a/libretroshare/src/services/p3photoservice.cc +++ b/libretroshare/src/services/p3photoservice.cc @@ -1,5 +1,5 @@ #include "p3photoservice.h" -#include "serialiser/rsphotoitems.h" +#include "rsitems/rsphotoitems.h" #include "retroshare/rsgxsflags.h" RsPhoto *rsPhoto = NULL; From 8341c683885caa032c9d0a1d0392aa5dffa2318b Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 18:54:07 +0200 Subject: [PATCH 80/94] removed old code --- libretroshare/src/rsitems/rsphotoitems.cc | 598 ---------------------- 1 file changed, 598 deletions(-) diff --git a/libretroshare/src/rsitems/rsphotoitems.cc b/libretroshare/src/rsitems/rsphotoitems.cc index e2f3c279a..9c2f217d9 100644 --- a/libretroshare/src/rsitems/rsphotoitems.cc +++ b/libretroshare/src/rsitems/rsphotoitems.cc @@ -48,137 +48,6 @@ RsItem *RsGxsPhotoSerialiser::create_item(uint16_t service, uint8_t item_sub_id) } } -#ifdef TO_REMOVE -uint32_t RsGxsPhotoSerialiser::size(RsItem* item) -{ - RsGxsPhotoPhotoItem* ppItem = NULL; - RsGxsPhotoAlbumItem* paItem = NULL; - RsGxsPhotoCommentItem* cItem = NULL; - - if((ppItem = dynamic_cast(item)) != NULL) - { - return sizeGxsPhotoPhotoItem(ppItem); - } - else if((paItem = dynamic_cast(item)) != NULL) - { - return sizeGxsPhotoAlbumItem(paItem); - } - else if((cItem = dynamic_cast(item)) != NULL) - { - return sizeGxsPhotoCommentItem(cItem); - } - else - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - -#endif - return NULL; - } - -} - -bool RsGxsPhotoSerialiser::serialise(RsItem* item, void* data, uint32_t* size) -{ - - RsGxsPhotoPhotoItem* ppItem = NULL; - RsGxsPhotoAlbumItem* paItem = NULL; - RsGxsPhotoCommentItem* cItem = NULL; - - if((ppItem = dynamic_cast(item)) != NULL) - { - return serialiseGxsPhotoPhotoItem(ppItem, data, size); - } - else if((paItem = dynamic_cast(item)) != NULL) - { - return serialiseGxsPhotoAlbumItem(paItem, data, size); - }else if((cItem = dynamic_cast(item)) != NULL) - { - return serialiseGxsPhotoCommentItem(cItem, data, size); - } - else - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - -#endif - return false; - } - -} - -RsItem* RsGxsPhotoSerialiser::deserialise(void* data, uint32_t* size) -{ - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_PHOTO != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM: - return deserialiseGxsPhotoPhotoItem(data, size); - case RS_PKT_SUBTYPE_PHOTO_ITEM: - return deserialiseGxsPhotoAlbumItem(data, size); - case RS_PKT_SUBTYPE_PHOTO_COMMENT_ITEM: - return deserialiseGxsPhotoCommentItem(data, size); - default: - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialise(): subtype could not be dealt with" - << std::endl; -#endif - break; - } - } - return NULL; -} - -uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoAlbumItem(RsGxsPhotoAlbumItem* item) -{ - - const RsPhotoAlbum& album = item->album; - uint32_t s = 8; // header - - s += GetTlvStringSize(album.mCaption); - s += GetTlvStringSize(album.mCategory); - s += GetTlvStringSize(album.mDescription); - s += GetTlvStringSize(album.mHashTags); - s += GetTlvStringSize(album.mOther); - s += GetTlvStringSize(album.mPhotoPath); - s += GetTlvStringSize(album.mPhotographer); - s += GetTlvStringSize(album.mWhen); - s += GetTlvStringSize(album.mWhere); - - RsTlvBinaryData b(item->PacketService()); // TODO, need something more persisitent - b.setBinData(album.mThumbnail.data, album.mThumbnail.size); - s += GetTlvStringSize(album.mThumbnail.type); - s += b.TlvSize(); - - return s; -} - -uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoCommentItem(RsGxsPhotoCommentItem *item) -{ - - const RsPhotoComment& comment = item->comment; - uint32_t s = 8; // header - - s += GetTlvStringSize(comment.mComment); - s += 4; // mflags - - return s; - -} -#endif - void RsGxsPhotoAlbumItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_CAPTION, album.mCaption, "mCaption"); @@ -196,174 +65,6 @@ void RsGxsPhotoAlbumItem::serial_process(RsGenericSerializer::SerializeJob j,RsG RsTypeSerializer::serial_process(j,ctx,b,"thumbnail binary data") ; } - -#ifdef TO_REMOVE -bool RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem(RsGxsPhotoAlbumItem* item, void* data, - uint32_t* size) -{ - -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsPhotoAlbumItem(item); - uint32_t offset = 0; - - if(*size < tlvsize){ -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsPhotoAlbumItem */ - - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_CAPTION, item->album.mCaption); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_CATEGORY, item->album.mCategory); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DESCR, item->album.mDescription); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_TAG, item->album.mHashTags); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->album.mOther); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PATH, item->album.mPhotoPath); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->album.mPhotographer); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DATE, item->album.mWhen); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->album.mWhere); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PIC_TYPE, item->album.mThumbnail.type); - RsTlvBinaryData b(RS_SERVICE_GXS_TYPE_PHOTO); // TODO, need something more persisitent - b.setBinData(item->album.mThumbnail.data, item->album.mThumbnail.size); - ok &= b.SetTlv(data, tlvsize, &offset); - - if(offset != tlvsize) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXS_PHOTO_SERIAL_DEBUG - if (!ok) - { - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoAlbumItem() NOK" << std::endl; - } -#endif - - return ok; -} - -RsGxsPhotoAlbumItem* RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem(void* data, - uint32_t* size) -{ - - -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_PHOTO != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_PHOTO_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsPhotoAlbumItem* item = new RsGxsPhotoAlbumItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_CAPTION, item->album.mCaption); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_CATEGORY, item->album.mCategory); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DESCR, item->album.mDescription); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_HASH_TAG, item->album.mHashTags); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->album.mOther); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PATH, item->album.mPhotoPath); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->album.mPhotographer); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DATE, item->album.mWhen); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->album.mWhere); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PIC_TYPE, item->album.mThumbnail.type); - - RsTlvBinaryData b(RS_SERVICE_GXS_TYPE_PHOTO); // TODO, need something more persisitent - ok &= b.GetTlv(data, rssize, &offset); - item->album.mThumbnail.data = (uint8_t*)b.bin_data; - item->album.mThumbnail.size = b.bin_len; - b.TlvShallowClear(); - - if (offset != rssize) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoAlbumItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -uint32_t RsGxsPhotoSerialiser::sizeGxsPhotoPhotoItem(RsGxsPhotoPhotoItem* item) -{ - - const RsPhotoPhoto& photo = item->photo; - - uint32_t s = 8; // header size - s += GetTlvStringSize(photo.mCaption); - s += GetTlvStringSize(photo.mCategory); - s += GetTlvStringSize(photo.mDescription); - s += GetTlvStringSize(photo.mHashTags); - s += GetTlvStringSize(photo.mOther); - s += GetTlvStringSize(photo.mPhotographer); - s += GetTlvStringSize(photo.mWhen); - s += GetTlvStringSize(photo.mWhere); - - RsTlvBinaryData b(item->PacketService()); // TODO, need something more persisitent - b.setBinData(photo.mThumbnail.data, photo.mThumbnail.size); - s += GetTlvStringSize(photo.mThumbnail.type); - s += b.TlvSize(); - - return s; -} -#endif - void RsGxsPhotoPhotoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx, TLV_TYPE_STR_CAPTION, photo.mCaption); @@ -379,276 +80,12 @@ void RsGxsPhotoPhotoItem::serial_process(RsGenericSerializer::SerializeJob j,RsG RsTlvBinaryDataRef b(RS_SERVICE_GXS_TYPE_PHOTO,photo.mThumbnail.data, photo.mThumbnail.size); RsTypeSerializer::serial_process(j,ctx, b, "mThumbnail") ; } - -#ifdef TO_REMOVE -bool RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem(RsGxsPhotoPhotoItem* item, void* data, - uint32_t* size) -{ - - -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsPhotoPhotoItem(item); - uint32_t offset = 0; - - if(*size < tlvsize){ -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsPhotoAlbumItem */ - - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_CAPTION, item->photo.mCaption); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_CATEGORY, item->photo.mCategory); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DESCR, item->photo.mDescription); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_TAG, item->photo.mHashTags); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->photo.mOther); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PIC_AUTH, item->photo.mPhotographer); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DATE, item->photo.mWhen); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->photo.mWhere); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PIC_TYPE, item->photo.mThumbnail.type); - RsTlvBinaryData b(RS_SERVICE_GXS_TYPE_PHOTO); // TODO, need something more persisitent - b.setBinData(item->photo.mThumbnail.data, item->photo.mThumbnail.size); - ok &= b.SetTlv(data, tlvsize, &offset); - - if(offset != tlvsize) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXS_PHOTO_SERIAL_DEBUG - if (!ok) - { - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoPhotoItem() NOK" << std::endl; - } -#endif - - return ok; -} - -RsGxsPhotoPhotoItem* RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem(void* data, - uint32_t* size) -{ - - -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_PHOTO != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_PHOTO_SHOW_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsPhotoPhotoItem* item = new RsGxsPhotoPhotoItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_CAPTION, item->photo.mCaption); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_CATEGORY, item->photo.mCategory); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DESCR, item->photo.mDescription); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_HASH_TAG, item->photo.mHashTags); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->photo.mOther); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PIC_AUTH, item->photo.mPhotographer); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DATE, item->photo.mWhen); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->photo.mWhere); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PIC_TYPE, item->photo.mThumbnail.type); - - RsTlvBinaryData b(RS_SERVICE_GXS_TYPE_PHOTO); // TODO, need something more persisitent - ok &= b.GetTlv(data, rssize, &offset); - item->photo.mThumbnail.data = (uint8_t*)(b.bin_data); - item->photo.mThumbnail.size = b.bin_len; - b.TlvShallowClear(); - - if (offset != rssize) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -#endif - void RsGxsPhotoCommentItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_COMMENT,comment.mComment,"mComment"); RsTypeSerializer::serial_process(j,ctx,comment.mCommentFlag,"mCommentFlag"); } -#ifdef TO_REMOVE -bool RsGxsPhotoSerialiser::serialiseGxsPhotoCommentItem (RsGxsPhotoCommentItem *item, void *data, uint32_t *size) -{ - - -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoCommentItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsPhotoCommentItem(item); - uint32_t offset = 0; - - if(*size < tlvsize){ -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoCommentItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsPhotoAlbumItem */ - - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_COMMENT, item->comment.mComment); - ok &= setRawUInt32(data, tlvsize, &offset, item->comment.mCommentFlag); - - if(offset != tlvsize) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoCommentItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXS_PHOTO_SERIAL_DEBUG - if (!ok) - { - std::cerr << "RsGxsPhotoSerialiser::serialiseGxsPhotoCommentItem() NOK" << std::endl; - } -#endif - - return ok; -} - -RsGxsPhotoCommentItem * RsGxsPhotoSerialiser::deserialiseGxsPhotoCommentItem(void *data, uint32_t *size) -{ - - -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoPhotoItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_PHOTO != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_PHOTO_COMMENT_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoCommentItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoCommentItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsPhotoCommentItem* item = new RsGxsPhotoCommentItem(); - - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_COMMENT, item->comment.mComment); - ok &= getRawUInt32(data, rssize, &offset, &(item->comment.mCommentFlag)); - - if (offset != rssize) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoCommentItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXS_PHOTO_SERIAL_DEBUG - std::cerr << "RsGxsPhotoSerialiser::deserialiseGxsPhotoCommentItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} -#endif - void RsGxsPhotoAlbumItem::clear() { album.mCaption.clear(); @@ -669,41 +106,6 @@ void RsGxsPhotoCommentItem::clear() comment.mCommentFlag = 0; } -#ifdef TO_REMOVE -std::ostream& RsGxsPhotoCommentItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsPhotoCommentItem", indent); - uint16_t int_Indent = indent + 2; - - - printRsItemEnd(out ,"RsGxsPhotoCommentItem", indent); - return out; -} - -std::ostream& RsGxsPhotoAlbumItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsPhotoAlbumItem", indent); - uint16_t int_Indent = indent + 2; - - out << album << std::endl; - - printRsItemEnd(out ,"RsGxsPhotoAlbumItem", indent); - return out; -} - -std::ostream& RsGxsPhotoPhotoItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsPhotoPhotoItem", indent); - uint16_t int_Indent = indent + 2; - - - printRsItemEnd(out ,"RsGxsPhotoPhotoItem", indent); - return out; -} - - -#endif - void RsGxsPhotoPhotoItem::clear() { photo.mCaption.clear(); From 23492698d4c38595045e6270136fbd3eec7b6112 Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 23:28:56 +0200 Subject: [PATCH 81/94] switch rsrecognitems to new serialization --- .../src/serialiser/rsgxsrecognitems.cc | 64 ++++++++++++++- .../src/serialiser/rsgxsrecognitems.h | 82 +++++++------------ 2 files changed, 89 insertions(+), 57 deletions(-) diff --git a/libretroshare/src/serialiser/rsgxsrecognitems.cc b/libretroshare/src/serialiser/rsgxsrecognitems.cc index 11317ad3c..a95cf8f60 100644 --- a/libretroshare/src/serialiser/rsgxsrecognitems.cc +++ b/libretroshare/src/serialiser/rsgxsrecognitems.cc @@ -25,6 +25,7 @@ #include "serialiser/rsgxsrecognitems.h" #include "serialiser/rsbaseserial.h" +#include "serialization/rstypeserializer.h" /*** #define RSSERIAL_DEBUG 1 @@ -34,9 +35,19 @@ /*************************************************************************/ -RsGxsRecognReqItem::~RsGxsRecognReqItem() +RsItem *RsGxsRecognSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const { - return; + if(service != RS_SERVICE_TYPE_GXS_RECOGN) + return NULL ; + + switch(item_sub_id) + { + case RS_PKT_SUBTYPE_RECOGN_REQ: return new RsGxsRecognReqItem(); + case RS_PKT_SUBTYPE_RECOGN_SIGNER: return new RsGxsRecognSignerItem(); + case RS_PKT_SUBTYPE_RECOGN_TAG: return new RsGxsRecognTagItem(); + default: + return NULL ; + } } void RsGxsRecognReqItem::clear() @@ -53,6 +64,12 @@ void RsGxsRecognReqItem::clear() sign.TlvClear(); } +#ifdef TO_REMOVE +RsGxsRecognReqItem::~RsGxsRecognReqItem() +{ + return; +} + std::ostream &RsGxsRecognReqItem::print(std::ostream &out, uint16_t indent) { @@ -104,6 +121,21 @@ uint32_t RsGxsRecognSerialiser::sizeReq(RsGxsRecognReqItem *item) return s; } +#endif + +void RsGxsRecognReqItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,issued_at ,"issued_at") ; + RsTypeSerializer::serial_process (j,ctx,period ,"period") ; + RsTypeSerializer::serial_process (j,ctx,tag_class ,"tag_class") ; + RsTypeSerializer::serial_process (j,ctx,tag_type ,"tag_type") ; + RsTypeSerializer::serial_process (j,ctx,identity ,"identity") ; + RsTypeSerializer::serial_process (j,ctx,1,nickname ,"nickname") ; + RsTypeSerializer::serial_process (j,ctx,1,comment ,"comment") ; + RsTypeSerializer::serial_process(j,ctx,sign ,"sign") ; +} + +#ifdef TO_REMOVE /* serialise the data to the buffer */ bool RsGxsRecognSerialiser::serialiseReq(RsGxsRecognReqItem *item, void *data, uint32_t *pktsize) { @@ -217,6 +249,7 @@ RsGxsRecognTagItem::~RsGxsRecognTagItem() { return; } +#endif void RsGxsRecognTagItem::clear() { @@ -232,6 +265,7 @@ void RsGxsRecognTagItem::clear() sign.TlvClear(); } +#ifdef TO_REMOVE std::ostream &RsGxsRecognTagItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsGxsRecognTagItem", indent); @@ -279,7 +313,20 @@ uint32_t RsGxsRecognSerialiser::sizeTag(RsGxsRecognTagItem *item) return s; } +#endif +void RsGxsRecognTagItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,valid_from ,"valid_from") ; + RsTypeSerializer::serial_process (j,ctx,valid_to ,"valid_to") ; + RsTypeSerializer::serial_process (j,ctx,tag_class ,"tag_class") ; + RsTypeSerializer::serial_process (j,ctx,tag_type ,"tag_type") ; + RsTypeSerializer::serial_process (j,ctx,identity ,"identity"); + RsTypeSerializer::serial_process (j,ctx,1,nickname ,"nickname") ; + RsTypeSerializer::serial_process(j,ctx,sign ,"sign") ; +} + +#ifdef TO_REMOVE /* serialise the data to the buffer */ bool RsGxsRecognSerialiser::serialiseTag(RsGxsRecognTagItem *item, void *data, uint32_t *pktsize) { @@ -393,6 +440,7 @@ RsGxsRecognSignerItem::~RsGxsRecognSignerItem() { return; } +#endif void RsGxsRecognSignerItem::clear() { @@ -401,6 +449,7 @@ void RsGxsRecognSignerItem::clear() sign.TlvClear(); } +#ifdef TO_REMOVE std::ostream &RsGxsRecognSignerItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsGxsRecognSignerItem", indent); @@ -435,7 +484,16 @@ uint32_t RsGxsRecognSerialiser::sizeSigner(RsGxsRecognSignerItem *item) return s; } +#endif +void RsGxsRecognSignerItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,signing_classes ,"signing_classes") ; + RsTypeSerializer::serial_process(j,ctx,key ,"key"); + RsTypeSerializer::serial_process(j,ctx,sign ,"sign") ; +} + +#ifdef TO_REMOVE /* serialise the data to the buffer */ bool RsGxsRecognSerialiser::serialiseSigner(RsGxsRecognSignerItem *item, void *data, uint32_t *pktsize) { @@ -604,6 +662,6 @@ RsItem *RsGxsRecognSerialiser::deserialise(void *data, uint32_t *pktsize) } /*************************************************************************/ - +#endif diff --git a/libretroshare/src/serialiser/rsgxsrecognitems.h b/libretroshare/src/serialiser/rsgxsrecognitems.h index aab0e3974..e072477ce 100644 --- a/libretroshare/src/serialiser/rsgxsrecognitems.h +++ b/libretroshare/src/serialiser/rsgxsrecognitems.h @@ -32,7 +32,6 @@ #include "rsitems/rsserviceids.h" #include "rsitems/itempriorities.h" -#include "serialiser/rsserial.h" #include "serialiser/rstlvkeys.h" #include "serialiser/rstlvidset.h" @@ -46,25 +45,23 @@ /**************************************************************************/ -#define RS_PKT_SUBTYPE_RECOGN_REQ 0x01 -#define RS_PKT_SUBTYPE_RECOGN_TAG 0x02 -#define RS_PKT_SUBTYPE_RECOGN_SIGNER 0x03 +#define RS_PKT_SUBTYPE_RECOGN_REQ 0x01 +#define RS_PKT_SUBTYPE_RECOGN_TAG 0x02 +#define RS_PKT_SUBTYPE_RECOGN_SIGNER 0x03 class RsGxsRecognReqItem: public RsItem { - public: - RsGxsRecognReqItem() - :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN, - RS_PKT_SUBTYPE_RECOGN_REQ) - { +public: + RsGxsRecognReqItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN, RS_PKT_SUBTYPE_RECOGN_REQ) + { setPriorityLevel(QOS_PRIORITY_DEFAULT); - return; + return; } -virtual ~RsGxsRecognReqItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual ~RsGxsRecognReqItem(){} + virtual void clear(); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t issued_at; uint32_t period; @@ -82,16 +79,15 @@ std::ostream &print(std::ostream &out, uint16_t indent = 0); class RsGxsRecognTagItem: public RsItem { public: - RsGxsRecognTagItem() - :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN, - RS_PKT_SUBTYPE_RECOGN_TAG) + RsGxsRecognTagItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN, RS_PKT_SUBTYPE_RECOGN_TAG) { setPriorityLevel(QOS_PRIORITY_DEFAULT); return; } -virtual ~RsGxsRecognTagItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual ~RsGxsRecognTagItem(){} + virtual void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t valid_from; uint32_t valid_to; @@ -107,52 +103,30 @@ std::ostream &print(std::ostream &out, uint16_t indent = 0); class RsGxsRecognSignerItem: public RsItem { - public: - RsGxsRecognSignerItem() - :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN, - RS_PKT_SUBTYPE_RECOGN_SIGNER) - { +public: + RsGxsRecognSignerItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN, RS_PKT_SUBTYPE_RECOGN_SIGNER) + { setPriorityLevel(QOS_PRIORITY_DEFAULT); - return; + return; } -virtual ~RsGxsRecognSignerItem(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual ~RsGxsRecognSignerItem(){} + virtual void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsTlvServiceIdSet signing_classes; - RsTlvPublicRSAKey key; // has from->to, and flags. + RsTlvPublicRSAKey key; // has from->to, and flags. RsTlvKeySignature sign; }; -class RsGxsRecognSerialiser: public RsSerialType +class RsGxsRecognSerialiser: public RsServiceSerializer { public: - RsGxsRecognSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_RECOGN) - { return; } -virtual ~RsGxsRecognSerialiser() - { return; } - - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - - private: - -virtual uint32_t sizeReq(RsGxsRecognReqItem *); -virtual bool serialiseReq(RsGxsRecognReqItem *item, void *data, uint32_t *size); -virtual RsGxsRecognReqItem *deserialiseReq(void *data, uint32_t *size); - -virtual uint32_t sizeTag(RsGxsRecognTagItem *); -virtual bool serialiseTag(RsGxsRecognTagItem *item, void *data, uint32_t *size); -virtual RsGxsRecognTagItem *deserialiseTag(void *data, uint32_t *size); - -virtual uint32_t sizeSigner(RsGxsRecognSignerItem *); -virtual bool serialiseSigner(RsGxsRecognSignerItem *item, void *data, uint32_t *size); -virtual RsGxsRecognSignerItem *deserialiseSigner(void *data, uint32_t *size); + RsGxsRecognSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_GXS_RECOGN) {} + virtual ~RsGxsRecognSerialiser() {} + virtual RsItem *create_item(uint16_t service, uint8_t item_sub_id) const; }; /**************************************************************************/ From 5cba0059c85ac7df40f4681199b5794d13a05097 Mon Sep 17 00:00:00 2001 From: csoler Date: Fri, 28 Apr 2017 23:32:47 +0200 Subject: [PATCH 82/94] moved recognitems to rsitems/ --- libretroshare/src/libretroshare.pro | 4 ++-- libretroshare/src/{serialiser => rsitems}/rsgxsrecognitems.cc | 3 +-- libretroshare/src/{serialiser => rsitems}/rsgxsrecognitems.h | 0 libretroshare/src/services/p3idservice.h | 2 +- libretroshare/src/util/rsrecogn.h | 2 +- 5 files changed, 5 insertions(+), 6 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rsgxsrecognitems.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rsgxsrecognitems.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 60fad8f7b..679e7c31a 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -485,7 +485,7 @@ HEADERS += rsitems/rsitem.h \ rsitems/rsdiscovery2items.h \ rsitems/rsheartbeatitems.h \ rsitems/rsrttitems.h \ - serialiser/rsgxsrecognitems.h \ + rsitems/rsgxsrecognitems.h \ rsitems/rsgxsupdateitems.h \ rsitems/rsserviceinfoitems.h \ @@ -630,7 +630,7 @@ SOURCES += serialiser/rsbaseserial.cc \ rsitems/rsbwctrlitems.cc \ rsitems/rsdiscovery2items.cc \ rsitems/rsrttitems.cc \ - serialiser/rsgxsrecognitems.cc \ + rsitems/rsgxsrecognitems.cc \ rsitems/rsgxsupdateitems.cc \ rsitems/rsserviceinfoitems.cc \ diff --git a/libretroshare/src/serialiser/rsgxsrecognitems.cc b/libretroshare/src/rsitems/rsgxsrecognitems.cc similarity index 99% rename from libretroshare/src/serialiser/rsgxsrecognitems.cc rename to libretroshare/src/rsitems/rsgxsrecognitems.cc index a95cf8f60..100ede2ba 100644 --- a/libretroshare/src/serialiser/rsgxsrecognitems.cc +++ b/libretroshare/src/rsitems/rsgxsrecognitems.cc @@ -23,8 +23,7 @@ * */ -#include "serialiser/rsgxsrecognitems.h" -#include "serialiser/rsbaseserial.h" +#include "rsitems/rsgxsrecognitems.h" #include "serialization/rstypeserializer.h" /*** diff --git a/libretroshare/src/serialiser/rsgxsrecognitems.h b/libretroshare/src/rsitems/rsgxsrecognitems.h similarity index 100% rename from libretroshare/src/serialiser/rsgxsrecognitems.h rename to libretroshare/src/rsitems/rsgxsrecognitems.h diff --git a/libretroshare/src/services/p3idservice.h b/libretroshare/src/services/p3idservice.h index caf29ee73..f745aca83 100644 --- a/libretroshare/src/services/p3idservice.h +++ b/libretroshare/src/services/p3idservice.h @@ -43,7 +43,7 @@ #include "pqi/authgpg.h" -#include "serialiser/rsgxsrecognitems.h" +#include "rsitems/rsgxsrecognitems.h" class PgpAuxUtils; diff --git a/libretroshare/src/util/rsrecogn.h b/libretroshare/src/util/rsrecogn.h index 6909a34ce..4f7b7cd2e 100644 --- a/libretroshare/src/util/rsrecogn.h +++ b/libretroshare/src/util/rsrecogn.h @@ -33,7 +33,7 @@ #include #include -#include "serialiser/rsgxsrecognitems.h" +#include "rsitems/rsgxsrecognitems.h" #include "retroshare/rsgxsifacetypes.h" namespace RsRecogn { From d58c638af893d68dcd7ba5fcd1d4d423fbe7ec58 Mon Sep 17 00:00:00 2001 From: csoler Date: Sat, 29 Apr 2017 21:46:54 +0200 Subject: [PATCH 83/94] switched wiki and wire items to new serialization --- libretroshare/src/serialiser/rswikiitems.cc | 47 +++++++++++++++ libretroshare/src/serialiser/rswikiitems.h | 66 +++++++-------------- libretroshare/src/serialiser/rswireitems.cc | 39 +++++++++++- libretroshare/src/serialiser/rswireitems.h | 42 +++++-------- 4 files changed, 120 insertions(+), 74 deletions(-) diff --git a/libretroshare/src/serialiser/rswikiitems.cc b/libretroshare/src/serialiser/rswikiitems.cc index fa4b2be72..dbd747b9a 100644 --- a/libretroshare/src/serialiser/rswikiitems.cc +++ b/libretroshare/src/serialiser/rswikiitems.cc @@ -31,7 +31,22 @@ #define GXSID_DEBUG 1 +RsItem *RsGxsWikiSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const +{ + if(service != RS_SERVICE_GXS_TYPE_WIKI) + return NULL ; + switch(item_sub_id) + { + case RS_PKT_SUBTYPE_WIKI_COLLECTION_ITEM: return new RsGxsWikiCollectionItem(); + case RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM: return new RsGxsWikiCommentItem(); + case RS_PKT_SUBTYPE_WIKI_SNAPSHOT_ITEM: return new RsGxsWikiSnapshotItem(); + default: + return NULL ; + } +} + +#ifdef TO_REMOVE uint32_t RsGxsWikiSerialiser::size(RsItem *item) { RsGxsWikiCollectionItem* grp_item = NULL; @@ -117,6 +132,7 @@ RsItem* RsGxsWikiSerialiser::deserialise(void* data, uint32_t* size) /*****************************************************************************************/ /*****************************************************************************************/ +#endif void RsGxsWikiCollectionItem::clear() { @@ -125,6 +141,7 @@ void RsGxsWikiCollectionItem::clear() collection.mHashTags.clear(); } +#ifdef TO_REMOVE std::ostream& RsGxsWikiCollectionItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsWikiCollectionItem", indent); @@ -154,7 +171,16 @@ uint32_t RsGxsWikiSerialiser::sizeGxsWikiCollectionItem(RsGxsWikiCollectionItem return s; } +#endif +void RsGxsWikiCollectionItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR ,collection.mDescription,"collection.mDescription") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_CATEGORY,collection.mCategory ,"collection.mCategory") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_TAG,collection.mHashTags ,"collection.mHashTags") ; +} + +#ifdef TO_REMOVE bool RsGxsWikiSerialiser::serialiseGxsWikiCollectionItem(RsGxsWikiCollectionItem *item, void *data, uint32_t *size) { @@ -277,6 +303,7 @@ RsGxsWikiCollectionItem* RsGxsWikiSerialiser::deserialiseGxsWikiCollectionItem(v /*****************************************************************************************/ /*****************************************************************************************/ +#endif void RsGxsWikiSnapshotItem::clear() { @@ -284,6 +311,7 @@ void RsGxsWikiSnapshotItem::clear() snapshot.mHashTags.clear(); } +#ifdef TO_REMOVE std::ostream& RsGxsWikiSnapshotItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsWikiSnapshotItem", indent); @@ -311,7 +339,15 @@ uint32_t RsGxsWikiSerialiser::sizeGxsWikiSnapshotItem(RsGxsWikiSnapshotItem *ite return s; } +#endif +void RsGxsWikiSnapshotItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_WIKI_PAGE,snapshot.mPage,"snapshot.mPage") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_TAG ,snapshot.mPage,"snapshot.mHashTags") ; +} + +#ifdef TO_REMOVE bool RsGxsWikiSerialiser::serialiseGxsWikiSnapshotItem(RsGxsWikiSnapshotItem *item, void *data, uint32_t *size) { @@ -431,12 +467,14 @@ RsGxsWikiSnapshotItem* RsGxsWikiSerialiser::deserialiseGxsWikiSnapshotItem(void /*****************************************************************************************/ /*****************************************************************************************/ +#endif void RsGxsWikiCommentItem::clear() { comment.mComment.clear(); } +#ifdef TO_REMOVE std::ostream& RsGxsWikiCommentItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsWikiCommentItem", indent); @@ -460,7 +498,14 @@ uint32_t RsGxsWikiSerialiser::sizeGxsWikiCommentItem(RsGxsWikiCommentItem *item) return s; } +#endif +void RsGxsWikiCommentItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_COMMENT,comment.mComment,"comment.mComment") ; +} + +#ifdef TO_REMOVE bool RsGxsWikiSerialiser::serialiseGxsWikiCommentItem(RsGxsWikiCommentItem *item, void *data, uint32_t *size) { @@ -578,3 +623,5 @@ RsGxsWikiCommentItem* RsGxsWikiSerialiser::deserialiseGxsWikiCommentItem(void *d /*****************************************************************************************/ /*****************************************************************************************/ + +#endif diff --git a/libretroshare/src/serialiser/rswikiitems.h b/libretroshare/src/serialiser/rswikiitems.h index 4247f9d3b..a50102ab4 100644 --- a/libretroshare/src/serialiser/rswikiitems.h +++ b/libretroshare/src/serialiser/rswikiitems.h @@ -29,28 +29,24 @@ #include #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" +#include "rsitems/rsitem.h" -#include "rsgxsitems.h" +#include "serialiser/rsgxsitems.h" #include "retroshare/rswiki.h" const uint8_t RS_PKT_SUBTYPE_WIKI_COLLECTION_ITEM = 0x02; -const uint8_t RS_PKT_SUBTYPE_WIKI_SNAPSHOT_ITEM = 0x03; -const uint8_t RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM = 0x04; +const uint8_t RS_PKT_SUBTYPE_WIKI_SNAPSHOT_ITEM = 0x03; +const uint8_t RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM = 0x04; class RsGxsWikiCollectionItem : public RsGxsGrpItem { - public: + RsGxsWikiCollectionItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_WIKI, RS_PKT_SUBTYPE_WIKI_COLLECTION_ITEM) {} + virtual ~RsGxsWikiCollectionItem() {} - RsGxsWikiCollectionItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_WIKI, - RS_PKT_SUBTYPE_WIKI_COLLECTION_ITEM) { return;} - virtual ~RsGxsWikiCollectionItem() { return;} - - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + void clear(); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsWikiCollection collection; }; @@ -59,11 +55,12 @@ class RsGxsWikiSnapshotItem : public RsGxsMsgItem { public: - RsGxsWikiSnapshotItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_WIKI, - RS_PKT_SUBTYPE_WIKI_SNAPSHOT_ITEM) {return; } - virtual ~RsGxsWikiSnapshotItem() { return;} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsWikiSnapshotItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_WIKI, RS_PKT_SUBTYPE_WIKI_SNAPSHOT_ITEM) {} + virtual ~RsGxsWikiSnapshotItem() {} + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + RsWikiSnapshot snapshot; }; @@ -71,42 +68,23 @@ class RsGxsWikiCommentItem : public RsGxsMsgItem { public: - RsGxsWikiCommentItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_WIKI, - RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM) { return; } - virtual ~RsGxsWikiCommentItem() { return; } + RsGxsWikiCommentItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_WIKI, RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM) {} + virtual ~RsGxsWikiCommentItem() {} void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + RsWikiComment comment; }; -class RsGxsWikiSerialiser : public RsSerialType +class RsGxsWikiSerialiser : public RsServiceSerializer { public: - RsGxsWikiSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_WIKI) - { return; } - virtual ~RsGxsWikiSerialiser() { return; } - - uint32_t size(RsItem *item); - bool serialise (RsItem *item, void *data, uint32_t *size); - RsItem * deserialise(void *data, uint32_t *size); - - private: - - uint32_t sizeGxsWikiCollectionItem(RsGxsWikiCollectionItem *item); - bool serialiseGxsWikiCollectionItem (RsGxsWikiCollectionItem *item, void *data, uint32_t *size); - RsGxsWikiCollectionItem * deserialiseGxsWikiCollectionItem(void *data, uint32_t *size); - - uint32_t sizeGxsWikiSnapshotItem(RsGxsWikiSnapshotItem *item); - bool serialiseGxsWikiSnapshotItem (RsGxsWikiSnapshotItem *item, void *data, uint32_t *size); - RsGxsWikiSnapshotItem * deserialiseGxsWikiSnapshotItem(void *data, uint32_t *size); - - uint32_t sizeGxsWikiCommentItem(RsGxsWikiCommentItem *item); - bool serialiseGxsWikiCommentItem (RsGxsWikiCommentItem *item, void *data, uint32_t *size); - RsGxsWikiCommentItem * deserialiseGxsWikiCommentItem(void *data, uint32_t *size); + RsGxsWikiSerialiser() :RsServiceSerializer(RS_SERVICE_GXS_TYPE_WIKI) {} + virtual ~RsGxsWikiSerialiser() {} + virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */) const; }; #endif /* RS_WIKI_ITEMS_H */ diff --git a/libretroshare/src/serialiser/rswireitems.cc b/libretroshare/src/serialiser/rswireitems.cc index 68ec68741..988189b60 100644 --- a/libretroshare/src/serialiser/rswireitems.cc +++ b/libretroshare/src/serialiser/rswireitems.cc @@ -26,12 +26,27 @@ #include #include "rswireitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" + +#include "serialization/rstypeserializer.h" #define WIRE_DEBUG 1 +RsItem *RsGxsWireSerialiser::create_item(uint16_t service,uint8_t item_subtype) const +{ + if(service != RS_SERVICE_GXS_TYPE_WIRE) + return NULL ; + + switch(item_subtype) + { + case RS_PKT_SUBTYPE_WIRE_GROUP_ITEM: return new RsGxsWireGroupItem(); + case RS_PKT_SUBTYPE_WIRE_PULSE_ITEM: return new RsGxsWirePulseItem(); + default: + return NULL ; + } +} + +#ifdef TO_REMOVE uint32_t RsGxsWireSerialiser::size(RsItem *item) { RsGxsWireGroupItem* grp_item = NULL; @@ -104,12 +119,14 @@ RsItem* RsGxsWireSerialiser::deserialise(void* data, uint32_t* size) /*****************************************************************************************/ /*****************************************************************************************/ +#endif void RsGxsWireGroupItem::clear() { group.mDescription.clear(); } +#ifdef TO_REMOVE std::ostream& RsGxsWireGroupItem::print(std::ostream& out, uint16_t indent) { printRsItemBase(out, "RsGxsWireGroupItem", indent); @@ -134,6 +151,14 @@ uint32_t RsGxsWireSerialiser::sizeGxsWireGroupItem(RsGxsWireGroupItem *item) return s; } +#endif + +void RsGxsWireGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR,group.mDescription,"group.mDescription") ; +} + +#ifdef TO_REMOVE bool RsGxsWireSerialiser::serialiseGxsWireGroupItem(RsGxsWireGroupItem *item, void *data, uint32_t *size) { @@ -287,6 +312,15 @@ uint32_t RsGxsWireSerialiser::sizeGxsWirePulseItem(RsGxsWirePulseItem *item) return s; } +#endif + +void RsGxsWirePulseItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,pulse.mPulseText,"pulse.mPulseText") ; + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_TAG,pulse.mHashTags,"pulse.mHashTags") ; +} + +#ifdef TO_REMOVE bool RsGxsWireSerialiser::serialiseGxsWirePulseItem(RsGxsWirePulseItem *item, void *data, uint32_t *size) { @@ -406,3 +440,4 @@ RsGxsWirePulseItem* RsGxsWireSerialiser::deserialiseGxsWirePulseItem(void *data, /*****************************************************************************************/ /*****************************************************************************************/ +#endif diff --git a/libretroshare/src/serialiser/rswireitems.h b/libretroshare/src/serialiser/rswireitems.h index 77258707a..137619aa6 100644 --- a/libretroshare/src/serialiser/rswireitems.h +++ b/libretroshare/src/serialiser/rswireitems.h @@ -43,13 +43,12 @@ class RsGxsWireGroupItem : public RsGxsGrpItem public: - RsGxsWireGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_WIRE, - RS_PKT_SUBTYPE_WIRE_GROUP_ITEM) { return;} - virtual ~RsGxsWireGroupItem() { return;} + RsGxsWireGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_WIRE, RS_PKT_SUBTYPE_WIRE_GROUP_ITEM) {} + virtual ~RsGxsWireGroupItem() {} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + void clear(); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsWireGroup group; }; @@ -58,36 +57,23 @@ class RsGxsWirePulseItem : public RsGxsMsgItem { public: - RsGxsWirePulseItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_WIRE, - RS_PKT_SUBTYPE_WIRE_PULSE_ITEM) {return; } - virtual ~RsGxsWirePulseItem() { return;} - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); + RsGxsWirePulseItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_WIRE, RS_PKT_SUBTYPE_WIRE_PULSE_ITEM) {} + virtual ~RsGxsWirePulseItem() {} + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + RsWirePulse pulse; }; -class RsGxsWireSerialiser : public RsSerialType +class RsGxsWireSerialiser : public RsServiceSerializer { public: - RsGxsWireSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_WIRE) - { return; } - virtual ~RsGxsWireSerialiser() { return; } + RsGxsWireSerialiser() :RsServiceSerializer(RS_SERVICE_GXS_TYPE_WIRE) {} + virtual ~RsGxsWireSerialiser() {} - uint32_t size(RsItem *item); - bool serialise (RsItem *item, void *data, uint32_t *size); - RsItem * deserialise(void *data, uint32_t *size); - - private: - - uint32_t sizeGxsWireGroupItem(RsGxsWireGroupItem *item); - bool serialiseGxsWireGroupItem (RsGxsWireGroupItem *item, void *data, uint32_t *size); - RsGxsWireGroupItem * deserialiseGxsWireGroupItem(void *data, uint32_t *size); - - uint32_t sizeGxsWirePulseItem(RsGxsWirePulseItem *item); - bool serialiseGxsWirePulseItem (RsGxsWirePulseItem *item, void *data, uint32_t *size); - RsGxsWirePulseItem * deserialiseGxsWirePulseItem(void *data, uint32_t *size); + virtual RsItem *create_item(uint16_t service,uint8_t item_subtype) const ; }; #endif /* RS_WIKI_ITEMS_H */ From 1159c863a228ca8bd0dcb8664637c737f1df8f41 Mon Sep 17 00:00:00 2001 From: csoler Date: Sat, 29 Apr 2017 21:50:55 +0200 Subject: [PATCH 84/94] moved wiki and wire items to rsitems/ --- libretroshare/src/libretroshare.pro | 8 ++++---- libretroshare/src/{serialiser => rsitems}/rswikiitems.cc | 4 ++-- libretroshare/src/{serialiser => rsitems}/rswikiitems.h | 2 +- libretroshare/src/{serialiser => rsitems}/rswireitems.cc | 0 libretroshare/src/{serialiser => rsitems}/rswireitems.h | 0 libretroshare/src/services/p3wiki.cc | 2 +- libretroshare/src/services/p3wire.cc | 2 +- 7 files changed, 9 insertions(+), 9 deletions(-) rename libretroshare/src/{serialiser => rsitems}/rswikiitems.cc (99%) rename libretroshare/src/{serialiser => rsitems}/rswikiitems.h (98%) rename libretroshare/src/{serialiser => rsitems}/rswireitems.cc (100%) rename libretroshare/src/{serialiser => rsitems}/rswireitems.h (100%) diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 679e7c31a..2c503532a 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -821,20 +821,20 @@ wikipoos { # Wiki Service HEADERS += retroshare/rswiki.h \ services/p3wiki.h \ - serialiser/rswikiitems.h + rsitems/rswikiitems.h SOURCES += services/p3wiki.cc \ - serialiser/rswikiitems.cc \ + rsitems/rswikiitems.cc \ } gxsthewire { # Wire Service HEADERS += retroshare/rswire.h \ services/p3wire.h \ - serialiser/rswireitems.h + rsitems/rswireitems.h SOURCES += services/p3wire.cc \ - serialiser/rswireitems.cc \ + rsitems/rswireitems.cc \ } # Posted Service diff --git a/libretroshare/src/serialiser/rswikiitems.cc b/libretroshare/src/rsitems/rswikiitems.cc similarity index 99% rename from libretroshare/src/serialiser/rswikiitems.cc rename to libretroshare/src/rsitems/rswikiitems.cc index dbd747b9a..8da92ab58 100644 --- a/libretroshare/src/serialiser/rswikiitems.cc +++ b/libretroshare/src/rsitems/rswikiitems.cc @@ -25,9 +25,9 @@ #include -#include "rswikiitems.h" +#include "rsitems/rswikiitems.h" #include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" +#include "serialization/rstypeserializer.h" #define GXSID_DEBUG 1 diff --git a/libretroshare/src/serialiser/rswikiitems.h b/libretroshare/src/rsitems/rswikiitems.h similarity index 98% rename from libretroshare/src/serialiser/rswikiitems.h rename to libretroshare/src/rsitems/rswikiitems.h index a50102ab4..378b77e5a 100644 --- a/libretroshare/src/serialiser/rswikiitems.h +++ b/libretroshare/src/rsitems/rswikiitems.h @@ -30,8 +30,8 @@ #include "rsitems/rsserviceids.h" #include "rsitems/rsitem.h" +#include "rsitems/rsgxsitems.h" -#include "serialiser/rsgxsitems.h" #include "retroshare/rswiki.h" const uint8_t RS_PKT_SUBTYPE_WIKI_COLLECTION_ITEM = 0x02; diff --git a/libretroshare/src/serialiser/rswireitems.cc b/libretroshare/src/rsitems/rswireitems.cc similarity index 100% rename from libretroshare/src/serialiser/rswireitems.cc rename to libretroshare/src/rsitems/rswireitems.cc diff --git a/libretroshare/src/serialiser/rswireitems.h b/libretroshare/src/rsitems/rswireitems.h similarity index 100% rename from libretroshare/src/serialiser/rswireitems.h rename to libretroshare/src/rsitems/rswireitems.h diff --git a/libretroshare/src/services/p3wiki.cc b/libretroshare/src/services/p3wiki.cc index d91e3d5df..a707596c1 100644 --- a/libretroshare/src/services/p3wiki.cc +++ b/libretroshare/src/services/p3wiki.cc @@ -25,7 +25,7 @@ #include "services/p3wiki.h" #include "retroshare/rsgxsflags.h" -#include "serialiser/rswikiitems.h" +#include "rsitems/rswikiitems.h" #include "util/rsrandom.h" diff --git a/libretroshare/src/services/p3wire.cc b/libretroshare/src/services/p3wire.cc index 0e525d689..7edce4a4d 100644 --- a/libretroshare/src/services/p3wire.cc +++ b/libretroshare/src/services/p3wire.cc @@ -24,7 +24,7 @@ */ #include "services/p3wire.h" -#include "serialiser/rswireitems.h" +#include "rsitems/rswireitems.h" #include "util/rsrandom.h" From 4f92f483fa017598ffa20c7a75ce5509874344b3 Mon Sep 17 00:00:00 2001 From: csoler Date: Sat, 29 Apr 2017 23:02:44 +0200 Subject: [PATCH 85/94] dwicthed GxsTunnel items to new serialization --- libretroshare/src/gxstunnel/p3gxstunnel.cc | 12 ++- .../src/gxstunnel/rsgxstunnelitems.cc | 91 +++++++++++++++++++ .../src/gxstunnel/rsgxstunnelitems.h | 41 ++------- .../src/serialization/rstypeserializer.h | 16 ++-- 4 files changed, 115 insertions(+), 45 deletions(-) diff --git a/libretroshare/src/gxstunnel/p3gxstunnel.cc b/libretroshare/src/gxstunnel/p3gxstunnel.cc index 3ad4198a9..75f50c7d9 100644 --- a/libretroshare/src/gxstunnel/p3gxstunnel.cc +++ b/libretroshare/src/gxstunnel/p3gxstunnel.cc @@ -1185,7 +1185,9 @@ bool p3GxsTunnelService::locked_sendClearTunnelData(RsGxsTunnelDHPublicKeyItem * // RsTurtleGenericDataItem *gitem = new RsTurtleGenericDataItem ; - uint32_t rssize = item->serial_size() ; + RsGxsTunnelSerialiser ser ; + + uint32_t rssize = ser.size(item); gitem->data_size = rssize + 8 ; gitem->data_bytes = rs_malloc(rssize+8) ; @@ -1198,7 +1200,7 @@ bool p3GxsTunnelService::locked_sendClearTunnelData(RsGxsTunnelDHPublicKeyItem * // by convention, we use a IV of 0 for unencrypted data. memset(gitem->data_bytes,0,8) ; - if(!item->serialise(&((uint8_t*)gitem->data_bytes)[8],rssize)) + if(!ser.serialise(item,&((uint8_t*)gitem->data_bytes)[8],&rssize)) { std::cerr << "(EE) Could not serialise item!!!" << std::endl; delete gitem ; @@ -1220,10 +1222,12 @@ bool p3GxsTunnelService::locked_sendClearTunnelData(RsGxsTunnelDHPublicKeyItem * bool p3GxsTunnelService::locked_sendEncryptedTunnelData(RsGxsTunnelItem *item) { - uint32_t rssize = item->serial_size(); + RsGxsTunnelSerialiser ser; + + uint32_t rssize = ser.size(item); RsTemporaryMemory buff(rssize) ; - if(!item->serialise(buff,rssize)) + if(!ser.serialise(item,buff,&rssize)) { std::cerr << "(EE) GxsTunnelService::sendEncryptedTunnelData(): Could not serialise item!" << std::endl; return false; diff --git a/libretroshare/src/gxstunnel/rsgxstunnelitems.cc b/libretroshare/src/gxstunnel/rsgxstunnelitems.cc index be0ff42c7..5f14fe079 100644 --- a/libretroshare/src/gxstunnel/rsgxstunnelitems.cc +++ b/libretroshare/src/gxstunnel/rsgxstunnelitems.cc @@ -28,6 +28,7 @@ #include #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" +#include "serialization/rstypeserializer.h" #include "util/rsprint.h" #include "util/rsmemory.h" @@ -35,6 +36,23 @@ //#define GXS_TUNNEL_ITEM_DEBUG 1 +RsItem *RsGxsTunnelSerialiser::create_item(uint16_t service,uint8_t item_subtype) const +{ + if(service != RS_SERVICE_TYPE_GXS_TUNNEL) + return NULL ; + + switch(item_subtype) + { + case RS_PKT_SUBTYPE_GXS_TUNNEL_DATA: return new RsGxsTunnelDataItem(); + case RS_PKT_SUBTYPE_GXS_TUNNEL_DATA_ACK: return new RsGxsTunnelDataAckItem(); + case RS_PKT_SUBTYPE_GXS_TUNNEL_DH_PUBLIC_KEY: return new RsGxsTunnelDHPublicKeyItem(); + case RS_PKT_SUBTYPE_GXS_TUNNEL_STATUS: return new RsGxsTunnelStatusItem(); + default: + return NULL ; + } +} + +#ifdef TO_REMOVE std::ostream& RsGxsTunnelDHPublicKeyItem::print(std::ostream &out, uint16_t indent) { printRsItemBase(out, "RsGxsTunnelDHPublicKeyItem", indent); @@ -87,12 +105,14 @@ std::ostream& RsGxsTunnelStatusItem::print(std::ostream &out, uint16_t indent) } /*************************************************************************/ +#endif RsGxsTunnelDHPublicKeyItem::~RsGxsTunnelDHPublicKeyItem() { BN_free(public_key) ; } +#ifdef TO_REMOVE /*************************************************************************/ RsItem *RsGxsTunnelSerialiser::deserialise(void *data, uint32_t *pktsize) @@ -176,7 +196,54 @@ uint32_t RsGxsTunnelStatusItem::serial_size() return s ; } /*************************************************************************/ +#endif +void RsGxsTunnelDHPublicKeyItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,public_key,"public_key") ; + RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; + RsTypeSerializer::serial_process(j,ctx,gxs_key,"gxs_key") ; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, BIGNUM * const & member) +{ + uint32_t s = BN_num_bytes(member) ; + + if(size < offset + 4 + s) + return false ; + + bool ok = true ; + ok &= setRawUInt32(data, size, &offset, s); + + BN_bn2bin(member,&((unsigned char *)data)[offset]) ; + offset += s ; + + return ok; +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, BIGNUM *& member) +{ + uint32_t s=0 ; + bool ok = true ; + ok &= getRawUInt32(data, size, &offset, &s); + + if(s > size || size - s < offset) + return false ; + + member = BN_bin2bn(&((unsigned char *)data)[offset],s,NULL) ; + offset += s ; + + return ok; +} +template<> uint32_t RsTypeSerializer::serial_size(BIGNUM * const & member) +{ + return 4 + BN_num_bytes(member) ; +} +template<> void RsTypeSerializer::print_data(const std::string& name,BIGNUM * const & /* member */) +{ + std::cerr << "[BIGNUM] : " << name << std::endl; +} + +#ifdef TO_REMOVE bool RsGxsTunnelDHPublicKeyItem::serialise(void *data,uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -211,7 +278,14 @@ bool RsGxsTunnelDHPublicKeyItem::serialise(void *data,uint32_t& pktsize) } return ok ; } +#endif +void RsGxsTunnelStatusItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,status,"status") ; +} + +#ifdef TO_REMOVE bool RsGxsTunnelStatusItem::serialise(void *data, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -249,7 +323,23 @@ bool RsGxsTunnelStatusItem::serialise(void *data, uint32_t& pktsize) return ok; } +#endif +void RsGxsTunnelDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,unique_item_counter,"unique_item_counter") ; + RsTypeSerializer::serial_process(j,ctx,flags ,"flags") ; + RsTypeSerializer::serial_process(j,ctx,service_id ,"service_id") ; + + RsTypeSerializer::TlvMemBlock_proxy mem(data,data_size) ; + RsTypeSerializer::serial_process(j,ctx,mem,"data") ; +} +void RsGxsTunnelDataAckItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,unique_item_counter,"unique_item_counter") ; +} + +#ifdef TO_REMOVE bool RsGxsTunnelDataItem::serialise(void *dt, uint32_t& pktsize) { uint32_t tlvsize = serial_size() ; @@ -489,6 +579,7 @@ RsGxsTunnelStatusItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelStatusItem( return item ; } +#endif diff --git a/libretroshare/src/gxstunnel/rsgxstunnelitems.h b/libretroshare/src/gxstunnel/rsgxstunnelitems.h index 4da26da0e..1bec905c8 100644 --- a/libretroshare/src/gxstunnel/rsgxstunnelitems.h +++ b/libretroshare/src/gxstunnel/rsgxstunnelitems.h @@ -60,10 +60,6 @@ class RsGxsTunnelItem: public RsItem virtual ~RsGxsTunnelItem() {} virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0 ; - - virtual bool serialise(void *data,uint32_t& size) = 0 ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() = 0 ; // deserialise is handled using a constructor }; /*! @@ -81,10 +77,8 @@ public: virtual ~RsGxsTunnelDataItem() {} virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint64_t unique_item_counter; // this allows to make the item unique uint32_t flags; // mainly NEEDS_HACK? @@ -103,10 +97,8 @@ class RsGxsTunnelStatusItem: public RsGxsTunnelItem RsGxsTunnelStatusItem(void *data,uint32_t size) ; // deserialization virtual ~RsGxsTunnelStatusItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t status ; }; @@ -120,12 +112,10 @@ class RsGxsTunnelDataAckItem: public RsGxsTunnelItem RsGxsTunnelDataAckItem(void *data,uint32_t size) ; // deserialization virtual ~RsGxsTunnelDataAckItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); - uint64_t unique_item_counter ; // unique identifier for that item + uint64_t unique_item_counter ; // unique identifier for that item }; @@ -139,10 +129,8 @@ class RsGxsTunnelDHPublicKeyItem: public RsGxsTunnelItem RsGxsTunnelDHPublicKeyItem(void *data,uint32_t size) ; // deserialization virtual ~RsGxsTunnelDHPublicKeyItem() ; - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); - virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ? - virtual uint32_t serial_size() ; // deserialise is handled using a constructor + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // Private data to DH public key item // @@ -157,24 +145,11 @@ class RsGxsTunnelDHPublicKeyItem: public RsGxsTunnelItem const RsGxsTunnelDHPublicKeyItem& operator=(const RsGxsTunnelDHPublicKeyItem&) { return *this ;} }; -class RsGxsTunnelSerialiser: public RsSerialType +class RsGxsTunnelSerialiser: public RsServiceSerializer { public: - RsGxsTunnelSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_GXS_TUNNEL) {} + RsGxsTunnelSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_GXS_TUNNEL) {} - virtual uint32_t size (RsItem *item) - { - return static_cast(item)->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - return static_cast(item)->serialise(data,*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) ; + virtual RsItem *create_item(uint16_t service,uint8_t item_subtype) const ; }; diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialization/rstypeserializer.h index 3ed0e9c16..a999a24d0 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialization/rstypeserializer.h @@ -339,15 +339,15 @@ class RsTypeSerializer } protected: - template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member); - template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); - template static uint32_t serial_size(const T& /* member */); - template static void print_data(const std::string& name,const T& /* member */); + template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member); + template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, T& member); + template static uint32_t serial_size(const T& /* member */); + template static void print_data(const std::string& name,const T& /* member */); - template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, uint16_t type_id,const T& member); - template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset,uint16_t type_id, T& member); - template static uint32_t serial_size(uint16_t type_id,const T& /* member */); - template static void print_data(const std::string& name,uint16_t type_id,const T& /* member */); + template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, uint16_t type_id,const T& member); + template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset,uint16_t type_id, T& member); + template static uint32_t serial_size(uint16_t type_id,const T& /* member */); + template static void print_data(const std::string& name,uint16_t type_id,const T& /* member */); template static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsGenericIdType& member); template static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsGenericIdType& member); From e401b90e023d9cbc86fdbb58a5cbc5b396244f4f Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 30 Apr 2017 16:05:37 +0200 Subject: [PATCH 86/94] moved rsserializer and rstypeserializer to serialiser/ --- libretroshare/src/chat/rschatitems.cc | 2 +- libretroshare/src/chat/rschatitems.h | 2 +- .../src/file_sharing/rsfilelistitems.cc | 2 +- .../src/file_sharing/rsfilelistitems.h | 2 +- .../src/ft/ftturtlefiletransferitem.cc | 2 +- libretroshare/src/grouter/grouteritems.cc | 2 +- .../src/gxstunnel/rsgxstunnelitems.cc | 2 +- libretroshare/src/libretroshare.pro | 8 +- libretroshare/src/rsitems/rsbanlistitems.cc | 2 +- libretroshare/src/rsitems/rsbanlistitems.h | 2 +- libretroshare/src/rsitems/rsbwctrlitems.h | 4 +- libretroshare/src/rsitems/rsconfigitems.cc | 2 +- libretroshare/src/rsitems/rsconfigitems.h | 2 +- .../src/rsitems/rsdiscovery2items.cc | 2 +- libretroshare/src/rsitems/rsdiscovery2items.h | 2 +- .../src/rsitems/rsfiletransferitems.cc | 2 +- .../src/rsitems/rsfiletransferitems.h | 2 +- .../src/rsitems/rsgxschannelitems.cc | 2 +- libretroshare/src/rsitems/rsgxschannelitems.h | 2 +- libretroshare/src/rsitems/rsgxscircleitems.cc | 2 +- .../src/rsitems/rsgxscommentitems.cc | 2 +- libretroshare/src/rsitems/rsgxsforumitems.cc | 2 +- libretroshare/src/rsitems/rsgxsforumitems.h | 2 +- libretroshare/src/rsitems/rsgxsiditems.cc | 2 +- libretroshare/src/rsitems/rsgxsrecognitems.cc | 2 +- .../src/rsitems/rsgxsreputationitems.cc | 2 +- .../src/rsitems/rsgxsreputationitems.h | 2 +- libretroshare/src/rsitems/rsgxsupdateitems.cc | 2 +- libretroshare/src/rsitems/rshistoryitems.cc | 2 +- libretroshare/src/rsitems/rshistoryitems.h | 2 +- libretroshare/src/rsitems/rsitem.h | 2 +- libretroshare/src/rsitems/rsmsgitems.cc | 2 +- libretroshare/src/rsitems/rsnxsitems.cc | 2 +- libretroshare/src/rsitems/rsphotoitems.cc | 2 +- libretroshare/src/rsitems/rsphotoitems.h | 2 +- libretroshare/src/rsitems/rspluginitems.h | 2 +- libretroshare/src/rsitems/rsposteditems.cc | 2 +- libretroshare/src/rsitems/rsrttitems.cc | 2 +- libretroshare/src/rsitems/rsrttitems.h | 2 +- .../src/rsitems/rsserviceinfoitems.cc | 2 +- libretroshare/src/rsitems/rsstatusitems.h | 2 +- libretroshare/src/rsitems/rswikiitems.cc | 2 +- libretroshare/src/rsitems/rswireitems.cc | 2 +- .../rsserializer.cc | 4 +- .../rsserializer.h | 0 .../rstypeserializer.cc | 0 .../rstypeserializer.h | 2 +- .../src/serialization/serial_test.cc | 196 ------------------ libretroshare/src/turtle/rsturtleitem.cc | 2 +- libretroshare/src/turtle/rsturtleitem.h | 2 +- 50 files changed, 52 insertions(+), 248 deletions(-) rename libretroshare/src/{serialization => serialiser}/rsserializer.cc (98%) rename libretroshare/src/{serialization => serialiser}/rsserializer.h (100%) rename libretroshare/src/{serialization => serialiser}/rstypeserializer.cc (100%) rename libretroshare/src/{serialization => serialiser}/rstypeserializer.h (99%) delete mode 100644 libretroshare/src/serialization/serial_test.cc diff --git a/libretroshare/src/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 06bb063a7..2b7dd67d8 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -29,7 +29,7 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #include "chat/rschatitems.h" diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 06de87c7f..ddc0a2b86 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -27,7 +27,7 @@ #include "openssl/bn.h" #include "retroshare/rstypes.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" #include "serialiser/rstlvkeys.h" #include "rsitems/rsserviceids.h" #include "rsitems/itempriorities.h" diff --git a/libretroshare/src/file_sharing/rsfilelistitems.cc b/libretroshare/src/file_sharing/rsfilelistitems.cc index 6934f29d2..7d91549d4 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.cc +++ b/libretroshare/src/file_sharing/rsfilelistitems.cc @@ -24,7 +24,7 @@ */ #include "serialiser/rsbaseserial.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #include "file_sharing/rsfilelistitems.h" diff --git a/libretroshare/src/file_sharing/rsfilelistitems.h b/libretroshare/src/file_sharing/rsfilelistitems.h index 8e45ef251..51e40b9c3 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.h +++ b/libretroshare/src/file_sharing/rsfilelistitems.h @@ -35,7 +35,7 @@ #include "serialiser/rstlvkeys.h" #include "gxs/rsgxsdata.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" // These items have "flag type" numbers, but this is not used. diff --git a/libretroshare/src/ft/ftturtlefiletransferitem.cc b/libretroshare/src/ft/ftturtlefiletransferitem.cc index 3009fb87c..44722af4b 100644 --- a/libretroshare/src/ft/ftturtlefiletransferitem.cc +++ b/libretroshare/src/ft/ftturtlefiletransferitem.cc @@ -30,7 +30,7 @@ #include #include -#include +#include void RsTurtleFileMapRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { diff --git a/libretroshare/src/grouter/grouteritems.cc b/libretroshare/src/grouter/grouteritems.cc index 48da81548..c856132db 100644 --- a/libretroshare/src/grouter/grouteritems.cc +++ b/libretroshare/src/grouter/grouteritems.cc @@ -3,7 +3,7 @@ #include "serialiser/rstlvbase.h" #include "grouteritems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /**********************************************************************************************/ /* SERIALISER STUFF */ diff --git a/libretroshare/src/gxstunnel/rsgxstunnelitems.cc b/libretroshare/src/gxstunnel/rsgxstunnelitems.cc index 5f14fe079..bb56e93cc 100644 --- a/libretroshare/src/gxstunnel/rsgxstunnelitems.cc +++ b/libretroshare/src/gxstunnel/rsgxstunnelitems.cc @@ -28,7 +28,7 @@ #include #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #include "util/rsprint.h" #include "util/rsmemory.h" diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 2c503532a..f8ea1f6a7 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -770,11 +770,11 @@ SOURCES += gxstunnel/p3gxstunnel.cc \ gxstunnel/rsgxstunnelitems.cc # new serialization code -HEADERS += serialization/rsserializer.h \ - serialization/rstypeserializer.h +HEADERS += serialiser/rsserializer.h \ + serialiser/rstypeserializer.h -SOURCES += serialization/rsserializer.cc \ - serialization/rstypeserializer.cc +SOURCES += serialiser/rsserializer.cc \ + serialiser/rstypeserializer.cc # Identity Service HEADERS += retroshare/rsidentity.h \ diff --git a/libretroshare/src/rsitems/rsbanlistitems.cc b/libretroshare/src/rsitems/rsbanlistitems.cc index 85acfb96c..358d20961 100644 --- a/libretroshare/src/rsitems/rsbanlistitems.cc +++ b/libretroshare/src/rsitems/rsbanlistitems.cc @@ -26,7 +26,7 @@ #include "serialiser/rsbaseserial.h" #include "rsitems/rsbanlistitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsbanlistitems.h b/libretroshare/src/rsitems/rsbanlistitems.h index 836fe1b7e..e5660e55c 100644 --- a/libretroshare/src/rsitems/rsbanlistitems.h +++ b/libretroshare/src/rsitems/rsbanlistitems.h @@ -32,7 +32,7 @@ #include "rsitems/rsitem.h" #include "rsitems/itempriorities.h" #include "serialiser/rstlvbanlist.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" #define RS_PKT_SUBTYPE_BANLIST_ITEM_deprecated 0x01 #define RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM_deprecated 0x02 diff --git a/libretroshare/src/rsitems/rsbwctrlitems.h b/libretroshare/src/rsitems/rsbwctrlitems.h index 570e0d87b..71ec641e1 100644 --- a/libretroshare/src/rsitems/rsbwctrlitems.h +++ b/libretroshare/src/rsitems/rsbwctrlitems.h @@ -32,8 +32,8 @@ #include "rsitems/rsserviceids.h" #include "rsitems/itempriorities.h" -#include "serialization/rsserializer.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rsserializer.h" +#include "serialiser/rstypeserializer.h" #define RS_PKT_SUBTYPE_BWCTRL_ALLOWED_ITEM 0x01 diff --git a/libretroshare/src/rsitems/rsconfigitems.cc b/libretroshare/src/rsitems/rsconfigitems.cc index 743e35871..15a8dd624 100644 --- a/libretroshare/src/rsitems/rsconfigitems.cc +++ b/libretroshare/src/rsitems/rsconfigitems.cc @@ -28,7 +28,7 @@ #include "rsitems/rsconfigitems.h" #include "retroshare/rspeers.h" // Needed for RsGroupInfo. -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*** * #define RSSERIAL_DEBUG 1 * #define RSSERIAL_ERROR_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsconfigitems.h b/libretroshare/src/rsitems/rsconfigitems.h index bc4b9e824..d4ea41898 100644 --- a/libretroshare/src/rsitems/rsconfigitems.h +++ b/libretroshare/src/rsitems/rsconfigitems.h @@ -39,7 +39,7 @@ #include "serialiser/rstlvkeyvalue.h" #include "serialiser/rstlvaddrs.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" class RsGroupInfo; diff --git a/libretroshare/src/rsitems/rsdiscovery2items.cc b/libretroshare/src/rsitems/rsdiscovery2items.cc index f9f19270c..0d1d3a493 100644 --- a/libretroshare/src/rsitems/rsdiscovery2items.cc +++ b/libretroshare/src/rsitems/rsdiscovery2items.cc @@ -27,7 +27,7 @@ #include "rsitems/rsdiscovery2items.h" #include "serialiser/rsbaseserial.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #if 0 diff --git a/libretroshare/src/rsitems/rsdiscovery2items.h b/libretroshare/src/rsitems/rsdiscovery2items.h index ce30a2928..012ebe1b5 100644 --- a/libretroshare/src/rsitems/rsdiscovery2items.h +++ b/libretroshare/src/rsitems/rsdiscovery2items.h @@ -35,7 +35,7 @@ #include "rsitems/rsitem.h" #include "rsitems/itempriorities.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" const uint8_t RS_PKT_SUBTYPE_DISC_PGP_LIST = 0x01; const uint8_t RS_PKT_SUBTYPE_DISC_PGP_CERT = 0x02; diff --git a/libretroshare/src/rsitems/rsfiletransferitems.cc b/libretroshare/src/rsitems/rsfiletransferitems.cc index cd0ea088d..7579c9560 100644 --- a/libretroshare/src/rsitems/rsfiletransferitems.cc +++ b/libretroshare/src/rsitems/rsfiletransferitems.cc @@ -28,7 +28,7 @@ #include "serialiser/rstlvbase.h" #include "rsitems/rsfiletransferitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*** * #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsfiletransferitems.h b/libretroshare/src/rsitems/rsfiletransferitems.h index b0ab0972a..85f6d5eab 100644 --- a/libretroshare/src/rsitems/rsfiletransferitems.h +++ b/libretroshare/src/rsitems/rsfiletransferitems.h @@ -34,7 +34,7 @@ #include "rsitems/rsserviceids.h" #include "rsitems/itempriorities.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" const uint8_t RS_PKT_SUBTYPE_FT_DATA_REQUEST = 0x01; const uint8_t RS_PKT_SUBTYPE_FT_DATA = 0x02; diff --git a/libretroshare/src/rsitems/rsgxschannelitems.cc b/libretroshare/src/rsitems/rsgxschannelitems.cc index 789357b4c..a8cc067b1 100644 --- a/libretroshare/src/rsitems/rsgxschannelitems.cc +++ b/libretroshare/src/rsitems/rsgxschannelitems.cc @@ -29,7 +29,7 @@ #include "serialiser/rstlvbase.h" #include "serialiser/rsbaseserial.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" RsItem *RsGxsChannelSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const { diff --git a/libretroshare/src/rsitems/rsgxschannelitems.h b/libretroshare/src/rsitems/rsgxschannelitems.h index b4caf5197..b0fc67987 100644 --- a/libretroshare/src/rsitems/rsgxschannelitems.h +++ b/libretroshare/src/rsitems/rsgxschannelitems.h @@ -37,7 +37,7 @@ #include "retroshare/rsgxschannels.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" #include "util/rsdir.h" diff --git a/libretroshare/src/rsitems/rsgxscircleitems.cc b/libretroshare/src/rsitems/rsgxscircleitems.cc index a5937b5ab..40ae6cf5f 100644 --- a/libretroshare/src/rsitems/rsgxscircleitems.cc +++ b/libretroshare/src/rsitems/rsgxscircleitems.cc @@ -27,7 +27,7 @@ #include "rsgxscircleitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" //#define CIRCLE_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsgxscommentitems.cc b/libretroshare/src/rsitems/rsgxscommentitems.cc index 4f655cc13..407f64204 100644 --- a/libretroshare/src/rsitems/rsgxscommentitems.cc +++ b/libretroshare/src/rsitems/rsgxscommentitems.cc @@ -28,7 +28,7 @@ #include "rsgxscommentitems.h" #include "serialiser/rstlvbase.h" #include "serialiser/rsbaseserial.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" //#define GXSCOMMENT_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsgxsforumitems.cc b/libretroshare/src/rsitems/rsgxsforumitems.cc index 462f4fcf6..fb5b8f632 100644 --- a/libretroshare/src/rsitems/rsgxsforumitems.cc +++ b/libretroshare/src/rsitems/rsgxsforumitems.cc @@ -27,7 +27,7 @@ #include "rsgxsforumitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" //#define GXSFORUM_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsgxsforumitems.h b/libretroshare/src/rsitems/rsgxsforumitems.h index 8e8d2bc24..5ce8a84ee 100644 --- a/libretroshare/src/rsitems/rsgxsforumitems.h +++ b/libretroshare/src/rsitems/rsgxsforumitems.h @@ -31,7 +31,7 @@ #include "rsitems/rsserviceids.h" #include "rsitems/rsgxsitems.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" #include "retroshare/rsgxsforums.h" diff --git a/libretroshare/src/rsitems/rsgxsiditems.cc b/libretroshare/src/rsitems/rsgxsiditems.cc index cb5ed324e..5bf55b549 100644 --- a/libretroshare/src/rsitems/rsgxsiditems.cc +++ b/libretroshare/src/rsitems/rsgxsiditems.cc @@ -31,7 +31,7 @@ #include "serialiser/rstlvstring.h" #include "util/rsstring.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #define GXSID_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsgxsrecognitems.cc b/libretroshare/src/rsitems/rsgxsrecognitems.cc index 100ede2ba..81b8d866b 100644 --- a/libretroshare/src/rsitems/rsgxsrecognitems.cc +++ b/libretroshare/src/rsitems/rsgxsrecognitems.cc @@ -24,7 +24,7 @@ */ #include "rsitems/rsgxsrecognitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsgxsreputationitems.cc b/libretroshare/src/rsitems/rsgxsreputationitems.cc index 1a50bf9dc..2a559b052 100644 --- a/libretroshare/src/rsitems/rsgxsreputationitems.cc +++ b/libretroshare/src/rsitems/rsgxsreputationitems.cc @@ -28,7 +28,7 @@ #include "serialiser/rsbaseserial.h" #include "rsitems/rsgxsreputationitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsgxsreputationitems.h b/libretroshare/src/rsitems/rsgxsreputationitems.h index 7c841bd4e..d4134f745 100644 --- a/libretroshare/src/rsitems/rsgxsreputationitems.h +++ b/libretroshare/src/rsitems/rsgxsreputationitems.h @@ -37,7 +37,7 @@ #include "retroshare/rsgxsifacetypes.h" #include "retroshare/rsreputations.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" #define RS_PKT_SUBTYPE_GXS_REPUTATION_CONFIG_ITEM 0x01 #define RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM_deprecated2 0x02 diff --git a/libretroshare/src/rsitems/rsgxsupdateitems.cc b/libretroshare/src/rsitems/rsgxsupdateitems.cc index 259cd1b4a..50f154cb2 100644 --- a/libretroshare/src/rsitems/rsgxsupdateitems.cc +++ b/libretroshare/src/rsitems/rsgxsupdateitems.cc @@ -23,7 +23,7 @@ * */ -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #include "serialiser/rsbaseserial.h" #include "rsgxsupdateitems.h" diff --git a/libretroshare/src/rsitems/rshistoryitems.cc b/libretroshare/src/rsitems/rshistoryitems.cc index 38f2f0254..3280f8eba 100644 --- a/libretroshare/src/rsitems/rshistoryitems.cc +++ b/libretroshare/src/rsitems/rshistoryitems.cc @@ -29,7 +29,7 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/rsitems/rshistoryitems.h b/libretroshare/src/rsitems/rshistoryitems.h index 56d12e559..04d3e9ca7 100644 --- a/libretroshare/src/rsitems/rshistoryitems.h +++ b/libretroshare/src/rsitems/rshistoryitems.h @@ -31,7 +31,7 @@ #include "rsitems/rsconfigitems.h" #include "retroshare/rstypes.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" /**************************************************************************/ diff --git a/libretroshare/src/rsitems/rsitem.h b/libretroshare/src/rsitems/rsitem.h index f7f6dae54..8dbda2fb3 100644 --- a/libretroshare/src/rsitems/rsitem.h +++ b/libretroshare/src/rsitems/rsitem.h @@ -2,7 +2,7 @@ #include "util/smallobject.h" #include "retroshare/rstypes.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" class RsItem: public RsMemoryManagement::SmallObject { diff --git a/libretroshare/src/rsitems/rsmsgitems.cc b/libretroshare/src/rsitems/rsmsgitems.cc index 20c98ad1b..09f305fc7 100644 --- a/libretroshare/src/rsitems/rsmsgitems.cc +++ b/libretroshare/src/rsitems/rsmsgitems.cc @@ -31,7 +31,7 @@ #include "rsitems/rsmsgitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*** #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsnxsitems.cc b/libretroshare/src/rsitems/rsnxsitems.cc index bfea43843..d6eb8b143 100644 --- a/libretroshare/src/rsitems/rsnxsitems.cc +++ b/libretroshare/src/rsitems/rsnxsitems.cc @@ -2,7 +2,7 @@ #include "util/rsprint.h" #include -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*** * #define RSSERIAL_DEBUG 1 diff --git a/libretroshare/src/rsitems/rsphotoitems.cc b/libretroshare/src/rsitems/rsphotoitems.cc index 9c2f217d9..9c9ff2d02 100644 --- a/libretroshare/src/rsitems/rsphotoitems.cc +++ b/libretroshare/src/rsitems/rsphotoitems.cc @@ -28,7 +28,7 @@ #include "rsitems/rsphotoitems.h" #include "serialiser/rstlvbinary.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #define GXS_PHOTO_SERIAL_DEBUG diff --git a/libretroshare/src/rsitems/rsphotoitems.h b/libretroshare/src/rsitems/rsphotoitems.h index cbaf29700..3819edb88 100644 --- a/libretroshare/src/rsitems/rsphotoitems.h +++ b/libretroshare/src/rsitems/rsphotoitems.h @@ -32,7 +32,7 @@ #include "rsitems/rsgxsitems.h" #include "serialiser/rsserial.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" #include "retroshare/rsphoto.h" diff --git a/libretroshare/src/rsitems/rspluginitems.h b/libretroshare/src/rsitems/rspluginitems.h index d21533c68..f5ff61321 100644 --- a/libretroshare/src/rsitems/rspluginitems.h +++ b/libretroshare/src/rsitems/rspluginitems.h @@ -29,7 +29,7 @@ #include "rsitems/rsitem.h" #include "rsitems/rsconfigitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" const uint8_t RS_PKT_CLASS_PLUGIN_SUBTYPE_HASHSET = 0x01 ; diff --git a/libretroshare/src/rsitems/rsposteditems.cc b/libretroshare/src/rsitems/rsposteditems.cc index 652abed05..378153df3 100644 --- a/libretroshare/src/rsitems/rsposteditems.cc +++ b/libretroshare/src/rsitems/rsposteditems.cc @@ -25,7 +25,7 @@ */ #include "rsitems/rsposteditems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" void RsGxsPostedPostItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { diff --git a/libretroshare/src/rsitems/rsrttitems.cc b/libretroshare/src/rsitems/rsrttitems.cc index 2ab7292e5..c4c499f79 100644 --- a/libretroshare/src/rsitems/rsrttitems.cc +++ b/libretroshare/src/rsitems/rsrttitems.cc @@ -32,7 +32,7 @@ #include -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /*************************************************************************/ diff --git a/libretroshare/src/rsitems/rsrttitems.h b/libretroshare/src/rsitems/rsrttitems.h index 8f635c3b9..35cf85bae 100644 --- a/libretroshare/src/rsitems/rsrttitems.h +++ b/libretroshare/src/rsitems/rsrttitems.h @@ -33,7 +33,7 @@ #include "rsitems/itempriorities.h" #include "serialiser/rsserial.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" /**************************************************************************/ diff --git a/libretroshare/src/rsitems/rsserviceinfoitems.cc b/libretroshare/src/rsitems/rsserviceinfoitems.cc index 35ba6d02d..d0d2070ab 100644 --- a/libretroshare/src/rsitems/rsserviceinfoitems.cc +++ b/libretroshare/src/rsitems/rsserviceinfoitems.cc @@ -24,7 +24,7 @@ */ #include "serialiser/rsbaseserial.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #include "rsitems/rsserviceinfoitems.h" /*** diff --git a/libretroshare/src/rsitems/rsstatusitems.h b/libretroshare/src/rsitems/rsstatusitems.h index 8c0316a9b..8a8a946b7 100644 --- a/libretroshare/src/rsitems/rsstatusitems.h +++ b/libretroshare/src/rsitems/rsstatusitems.h @@ -30,7 +30,7 @@ #include "rsitems/itempriorities.h" #include "rsitems/rsitem.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" /**************************************************************************/ diff --git a/libretroshare/src/rsitems/rswikiitems.cc b/libretroshare/src/rsitems/rswikiitems.cc index 8da92ab58..ec42e14f0 100644 --- a/libretroshare/src/rsitems/rswikiitems.cc +++ b/libretroshare/src/rsitems/rswikiitems.cc @@ -27,7 +27,7 @@ #include "rsitems/rswikiitems.h" #include "serialiser/rstlvbase.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #define GXSID_DEBUG 1 diff --git a/libretroshare/src/rsitems/rswireitems.cc b/libretroshare/src/rsitems/rswireitems.cc index 988189b60..55a56a803 100644 --- a/libretroshare/src/rsitems/rswireitems.cc +++ b/libretroshare/src/rsitems/rswireitems.cc @@ -27,7 +27,7 @@ #include "rswireitems.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" #define WIRE_DEBUG 1 diff --git a/libretroshare/src/serialization/rsserializer.cc b/libretroshare/src/serialiser/rsserializer.cc similarity index 98% rename from libretroshare/src/serialization/rsserializer.cc rename to libretroshare/src/serialiser/rsserializer.cc index f9619e839..bc1c9f92a 100644 --- a/libretroshare/src/serialization/rsserializer.cc +++ b/libretroshare/src/serialiser/rsserializer.cc @@ -3,8 +3,8 @@ #include "rsitems/rsitem.h" #include "util/rsprint.h" -#include "serialization/rsserializer.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rsserializer.h" +#include "serialiser/rstypeserializer.h" const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_NONE ( 0x0000 ); const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_CONFIG ( 0x0001 ); diff --git a/libretroshare/src/serialization/rsserializer.h b/libretroshare/src/serialiser/rsserializer.h similarity index 100% rename from libretroshare/src/serialization/rsserializer.h rename to libretroshare/src/serialiser/rsserializer.h diff --git a/libretroshare/src/serialization/rstypeserializer.cc b/libretroshare/src/serialiser/rstypeserializer.cc similarity index 100% rename from libretroshare/src/serialization/rstypeserializer.cc rename to libretroshare/src/serialiser/rstypeserializer.cc diff --git a/libretroshare/src/serialization/rstypeserializer.h b/libretroshare/src/serialiser/rstypeserializer.h similarity index 99% rename from libretroshare/src/serialization/rstypeserializer.h rename to libretroshare/src/serialiser/rstypeserializer.h index a999a24d0..6ad237be9 100644 --- a/libretroshare/src/serialization/rstypeserializer.h +++ b/libretroshare/src/serialiser/rstypeserializer.h @@ -7,7 +7,7 @@ #include "retroshare/rsflags.h" #include "retroshare/rsids.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" class RsTypeSerializer diff --git a/libretroshare/src/serialization/serial_test.cc b/libretroshare/src/serialization/serial_test.cc deleted file mode 100644 index a8d89a25f..000000000 --- a/libretroshare/src/serialization/serial_test.cc +++ /dev/null @@ -1,196 +0,0 @@ -// COMPILE_LINE: g++ -g serial_test.cc -I.. -o serial_test ../lib/libretroshare.a -lssl -lcrypto -lstdc++ -lpthread -// -// - -#include -#include - -#include "util/rsmemory.h" -#include "util/rsprint.h" -#include "serialiser/rsserial.h" - -#include "rsserializer.h" -#include "rstypeserializer.h" - -#define GET_VARIABLE_NAME(str) #str - -static const uint16_t RS_SERVICE_TYPE_TEST = 0xffff; -static const uint8_t RS_ITEM_SUBTYPE_TEST1 = 0x01 ; - -// Template serialization of RsTypeSerialiser::serial_process() for unknown/new types -// Here we do it for std::set as an example. -// -template<> uint32_t RsTypeSerializer::serial_size(const std::set& s) -{ - return s.size() * 4 + 4 ; -} -template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const std::set& member) -{ - uint32_t tlvsize = serial_size(member) ; - bool ok = true ; - uint32_t offset_save = offset ; - - if(tlvsize + offset > size) - { - std::cerr << "RsTypeSerializer::serialize: error. tlvsize+offset > size, where tlvsize=" << tlvsize << ", offset=" << offset << ", size=" << size << std::endl; - return false ; - } - - ok = ok && RsTypeSerializer::serialize(data,size,offset,member.size()) ; - - for(std::set::const_iterator it(member.begin());it!=member.end();++it) - ok = ok && RsTypeSerializer::serialize(data,size,offset,*it) ; - - if(!ok) - { - std::cerr << "(EE) Cannot serialize std::set" << std::endl; - offset = offset_save ; // return the data in the same condition - } - return ok ; -} - -template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, std::set& member) -{ - bool ok = true ; - uint32_t n = 0 ; - uint32_t offset_save = offset ; - member.clear(); - - ok = ok && RsTypeSerializer::deserialize(data,size,offset,n); - - for(uint32_t i=0;i" << std::endl; - offset = offset_save ; // return the data in the same condition - } - return ok; -} - -template<> void RsTypeSerializer::print_data(const std::string& s,const std::set& set) -{ - std::cerr << " [set] " << s << " : set of size " << set.size() << std::endl; -} - -// New item class. This class needs to define: -// - a serial_process method that tells which members to serialize -// - overload the clear() and print() methods of RsItem -// -class RsTestItem: public RsItem -{ - public: - RsTestItem() : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_TEST,RS_ITEM_SUBTYPE_TEST1) - { - str = "test string"; - ts = time(NULL) ; - - int_set.push_back(lrand48()) ; - int_set.push_back(lrand48()) ; - int_set.push_back(lrand48()) ; - } - - // Derived from RsItem - // - virtual void serial_process(RsItem::SerializeJob j, SerializeContext& ctx) - { - RsTypeSerializer::TlvString_proxy tt(str,TLV_TYPE_STR_DESCR) ; - - RsTypeSerializer::serial_process(j,ctx,ts ,GET_VARIABLE_NAME(ts) ) ; - RsTypeSerializer::serial_process(j,ctx,tt ,GET_VARIABLE_NAME(str) ) ; - RsTypeSerializer::serial_process(j,ctx,int_set,GET_VARIABLE_NAME(int_set) ) ; - } - - // Derived from RsItem, because they are pure virtuals. Normally print() should disappear soon. - // - virtual void clear() {} - virtual std::ostream& print(std::ostream&,uint16_t) {} - - private: - std::string str ; - uint64_t ts ; - std::vector int_set ; - - friend int main(int argc,char *argv[]); -}; - -// New user-defined serializer class. -// The only required member is the create_item() method, which creates the correct RsItem -// that corresponds to a specific (service,subtype) couple. -// -class RsTestSerializer: public RsSerializer -{ - public: - RsTestSerializer() : RsSerializer(RS_SERVICE_TYPE_TEST) {} - - virtual RsItem *create_item(uint16_t service_id,uint8_t subtype) - { - if(service_id != RS_SERVICE_TYPE_TEST) - return NULL ; - - switch(subtype) - { - case RS_ITEM_SUBTYPE_TEST1: return new RsTestItem(); - - default: - return NULL ; - } - } -}; - -// Methods to check the equality of items. -// -void check(const std::string& s1,const std::string& s2) { assert(s1 == s2) ; } -void check(const uint64_t& s1,const uint64_t& s2) { assert(s1 == s2) ; } -void check(const std::set& s1,const std::set& s2) { assert(s1 == s2) ; } -void check(const std::vector& s1,const std::vector& s2) { assert(s1 == s2) ; } - -int main(int argc,char *argv[]) -{ - try - { - RsTestItem t1 ; - - uint32_t size = RsTestSerializer().size(&t1); - - std::cerr << "t1.serial_size() = " << size << std::endl; - - // Allocate some memory to serialise to - // - RsTemporaryMemory mem1(size); - - std::cerr << "Item to be serialized:" << std::endl; - - RsTestSerializer().print(&t1) ; - RsTestSerializer().serialise(&t1,mem1,&size); - - std::cerr << "Serialized t1: " << RsUtil::BinToHex(mem1,mem1.size()) << std::endl; - - // Now deserialise into a new item - // - RsItem *t2 = RsTestSerializer().deserialise(mem1,&size); - - // make sure t1 is equal to t2 - // - check(t1.str,dynamic_cast(t2)->str) ; - check(t1.ts,dynamic_cast(t2)->ts) ; - check(t1.int_set,dynamic_cast(t2)->int_set) ; - - delete t2; - - return 0; - } - catch(std::exception& e) - { - std::cerr << "Exception caught: " << e.what() << std::endl; - return 1; - } -} - - diff --git a/libretroshare/src/turtle/rsturtleitem.cc b/libretroshare/src/turtle/rsturtleitem.cc index 2455c98e5..35b250117 100644 --- a/libretroshare/src/turtle/rsturtleitem.cc +++ b/libretroshare/src/turtle/rsturtleitem.cc @@ -6,7 +6,7 @@ #include "rsturtleitem.h" #include "turtleclientservice.h" -#include "serialization/rstypeserializer.h" +#include "serialiser/rstypeserializer.h" //#define P3TURTLE_DEBUG // -----------------------------------------------------------------------------------// diff --git a/libretroshare/src/turtle/rsturtleitem.h b/libretroshare/src/turtle/rsturtleitem.h index 8a8a1e49c..78f6155d8 100644 --- a/libretroshare/src/turtle/rsturtleitem.h +++ b/libretroshare/src/turtle/rsturtleitem.h @@ -13,7 +13,7 @@ #include "retroshare/rstypes.h" #include "turtle/turtletypes.h" -#include "serialization/rsserializer.h" +#include "serialiser/rsserializer.h" const uint8_t RS_TURTLE_SUBTYPE_STRING_SEARCH_REQUEST = 0x01 ; const uint8_t RS_TURTLE_SUBTYPE_SEARCH_RESULT = 0x02 ; From 14076de1e011212eff4f206cd79abf4fde47012f Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 30 Apr 2017 19:17:44 +0200 Subject: [PATCH 87/94] moved code of rsservicerserialiser into rsserializer.h/cc and renamed it into RsRawSerializer --- libretroshare/src/pqi/pqipersongrp.cc | 4 +- libretroshare/src/pqi/pqisslpersongrp.cc | 6 +- libretroshare/src/serialiser/rsserial.h | 19 +-- libretroshare/src/serialiser/rsserializer.cc | 73 +++++++++ libretroshare/src/serialiser/rsserializer.h | 150 +++++++++++++++++- .../src/serialiser/rsserviceserialiser.cc | 74 --------- .../src/serialiser/rsserviceserialiser.h | 10 -- .../src/serialiser/rstypeserializer.cc | 5 +- 8 files changed, 230 insertions(+), 111 deletions(-) diff --git a/libretroshare/src/pqi/pqipersongrp.cc b/libretroshare/src/pqi/pqipersongrp.cc index a30eb2738..dd9e645a3 100644 --- a/libretroshare/src/pqi/pqipersongrp.cc +++ b/libretroshare/src/pqi/pqipersongrp.cc @@ -699,7 +699,7 @@ pqiperson * pqipersongrpDummy::locked_createPerson(const RsPeerId& id, pqilisten NetBinDummy *d1 = new NetBinDummy(pqip, id, PQI_CONNECT_TCP); RsSerialiser *rss = new RsSerialiser(); - rss->addSerialType(new RsServiceSerialiser()); + rss->addSerialType(new RsRawSerialiser()); pqiconnect *pqic = new pqiconnect(pqip, rss, d1); @@ -709,7 +709,7 @@ pqiperson * pqipersongrpDummy::locked_createPerson(const RsPeerId& id, pqilisten NetBinDummy *d2 = new NetBinDummy(pqip, id, PQI_CONNECT_UDP); RsSerialiser *rss2 = new RsSerialiser(); - rss2->addSerialType(new RsServiceSerialiser()); + rss2->addSerialType(new RsRawSerialiser()); pqiconnect *pqic2 = new pqiconnect(pqip, rss2, d2); diff --git a/libretroshare/src/pqi/pqisslpersongrp.cc b/libretroshare/src/pqi/pqisslpersongrp.cc index a1173fd93..ad6ad098c 100644 --- a/libretroshare/src/pqi/pqisslpersongrp.cc +++ b/libretroshare/src/pqi/pqisslpersongrp.cc @@ -87,7 +87,7 @@ pqiperson * pqisslpersongrp::locked_createPerson(const RsPeerId& id, pqilistener RsSerialiser *rss = new RsSerialiser(); - rss->addSerialType(new RsServiceSerialiser()); + rss->addSerialType(new RsRawSerialiser()); pqiconnect *pqisc = new pqiconnect(pqip, rss, pqis); @@ -141,7 +141,7 @@ pqiperson * pqisslpersongrp::locked_createPerson(const RsPeerId& id, pqilistener ssl_tunnels[id] = pqis ; // keeps for getting crypt info per peer. RsSerialiser *rss = new RsSerialiser(); - rss->addSerialType(new RsServiceSerialiser()); + rss->addSerialType(new RsRawSerialiser()); pqiconnect *pqisc = new pqiconnect(pqip, rss, pqis); @@ -151,7 +151,7 @@ pqiperson * pqisslpersongrp::locked_createPerson(const RsPeerId& id, pqilistener pqissludp *pqius = new pqissludp(pqip, mLinkMgr); RsSerialiser *rss2 = new RsSerialiser(); - rss2->addSerialType(new RsServiceSerialiser()); + rss2->addSerialType(new RsRawSerialiser()); pqiconnect *pqiusc = new pqiconnect(pqip, rss2, pqius); diff --git a/libretroshare/src/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index 248c0a3bc..206f69608 100644 --- a/libretroshare/src/serialiser/rsserial.h +++ b/libretroshare/src/serialiser/rsserial.h @@ -65,24 +65,7 @@ const uint8_t RS_PKT_CLASS_CONFIG = 0x02; const uint8_t RS_PKT_SUBTYPE_DEFAULT = 0x01; /* if only one subtype */ class RsItem ; - -class RsSerialType -{ - public: - RsSerialType(uint32_t t); /* only uses top 24bits */ - RsSerialType(uint8_t ver, uint8_t cls, uint8_t t); - RsSerialType(uint8_t ver, uint16_t service); - -virtual ~RsSerialType(); - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - -uint32_t PacketId() const; - private: -uint32_t type; -}; +class RsSerialType ; class RsSerialiser diff --git a/libretroshare/src/serialiser/rsserializer.cc b/libretroshare/src/serialiser/rsserializer.cc index bc1c9f92a..ef85008aa 100644 --- a/libretroshare/src/serialiser/rsserializer.cc +++ b/libretroshare/src/serialiser/rsserializer.cc @@ -139,4 +139,77 @@ void RsGenericSerializer::print(RsItem *item) std::cerr << "******************************" << std::endl; } +uint32_t RsRawSerialiser::size(RsItem *i) +{ + RsRawItem *item = dynamic_cast(i); + + if (item) + { + return item->getRawLength(); + } + return 0; +} + +/* serialise the data to the buffer */ +bool RsRawSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) +{ + RsRawItem *item = dynamic_cast(i); + if (!item) + { + return false; + } + + #ifdef RSSERIAL_DEBUG + std::cerr << "RsRawSerialiser::serialise() serializing raw item. pktsize : " << *pktsize; + #endif + + uint32_t tlvsize = item->getRawLength(); + #ifdef RSSERIAL_DEBUG + std::cerr << "tlvsize : " << tlvsize << std::endl; + #endif + + if (*pktsize < tlvsize) + return false; /* not enough space */ + + if (tlvsize > getRsPktMaxSize()) + { + std::cerr << "(EE) Serialised packet is too big. Maximum allowed size is " << getRsPktMaxSize() << ". Serialised size is " << tlvsize << ". Please tune your service to correctly split packets" << std::endl; + return false; /* packet too big */ + } + + *pktsize = tlvsize; + + /* its serialised already!!! */ + memcpy(data, item->getRawData(), tlvsize); + + return true; +} + +RsItem *RsRawSerialiser::deserialise(void *data, uint32_t *pktsize) +{ + /* get the type and size */ + uint32_t rstype = getRsItemId(data); + uint32_t rssize = getRsItemSize(data); + + if (RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) + { + return NULL; /* wrong type */ + } + + if (*pktsize < rssize) /* check size */ + return NULL; /* not enough data */ + + if (rssize > getRsPktMaxSize()) + return NULL; /* packet too big */ + + /* set the packet length */ + *pktsize = rssize; + + RsRawItem *item = new RsRawItem(rstype, rssize); + void *item_data = item->getRawData(); + + memcpy(item_data, data, rssize); + + return item; +} diff --git a/libretroshare/src/serialiser/rsserializer.h b/libretroshare/src/serialiser/rsserializer.h index 2bea8d23f..639c75806 100644 --- a/libretroshare/src/serialiser/rsserializer.h +++ b/libretroshare/src/serialiser/rsserializer.h @@ -1,5 +1,124 @@ #pragma once +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Retroshare Serialization code // +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Classes +// ======= +// +// RsSerialiser ----------------+ std::map +// +// RsSerialType +// | +// +----------- RsRawSerializer +// | +// +----------- RsGenericSerializer +// | +// +----------- RsConfigSerializer +// | | +// | +----------- Specific config serializers +// | +----------- ... +// | +// +----------- RsServiceSerializer +// | +// +----------- Specific service serializers +// +----------- ... +// +----------- ... +// +// +// Steps to derive a serializer for a new service: +// ============================================== +// +// 1 - create a serializer class, and overload create_item() to create a new item of your own service for each item type constant: +// +// class MyServiceSerializer: public RsServiceSerializer +// { +// MyServiceSerializer() : RsServiceSerializer(MY_SERVICE_IDENTIFIER) {} +// +// RsItem *create_item(uint16_t service,uint8_t item_subtype) +// { +// if(service != MY_SERVICE_IDENTIFIER) return NULL ; +// +// switch(item_subtype) +// { +// case MY_ITEM_SUBTYPE_01: return new MyServiceItem(); +// default: +// return NULL ; +// } +// } +// } +// +// 2 - create your own items, and overload serial_process in order to define the serialized structure: +// +// class MyServiceItem: public RsItem +// { +// virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +// { +// RsTypeSerializer::serial_process (j,ctx,count,"count") ; // uint32_t is not really needed here, except for explicitly avoiding int types convertion +// RsTypeSerializer::serial_process (j,ctx,update_times,"update_times") ; // will serialize the map and its content +// RsTypeSerializer::serial_process(j,ctx,key,"key") ; // note the explicit call to TlvItem +// RsTypeSerializer::serial_process (j,ctx,dh_key,"dh_key") ; // template will automatically require serialise/deserialise/size/print_data for your type +// } +// +// private: +// uint32_t count ; // example of an int type. All int sizes are supported +// std::map update_times ; // example of a std::map. All std containers are supported. +// RsTlvSecurityKey key ; // example of a TlvItem class. +// BIGNUM *dh_key; // example of a class that needs its own serializer (see below) +// }; +// +// Some types may not be already handled by RsTypeSerializer, so in this case, you need to specialise the template for your own type. But this is quite unlikely to +// happen. In most cases, for instance in your structure types, serialization is directly done by calling RsTypeSerializer::serial_process() on each member of the type. +// In case you really need a specific serialization for soe particular type, here is how to do it, with the example of BIGNUM* (a crypto primitive): +// +// template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, BIGNUM * const & member) +// { +// uint32_t s = BN_num_bytes(member) ; +// +// if(size < offset + 4 + s) +// return false ; +// +// bool ok = true ; +// ok &= setRawUInt32(data, size, &offset, s); +// +// BN_bn2bin(member,&((unsigned char *)data)[offset]) ; +// offset += s ; +// +// return ok; +// } +// template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, BIGNUM *& member) +// { +// uint32_t s=0 ; +// bool ok = true ; +// ok &= getRawUInt32(data, size, &offset, &s); +// +// if(s > size || size - s < offset) +// return false ; +// +// member = BN_bin2bn(&((unsigned char *)data)[offset],s,NULL) ; +// offset += s ; +// +// return ok; +// } +// template<> uint32_t RsTypeSerializer::serial_size(BIGNUM * const & member) +// { +// return 4 + BN_num_bytes(member) ; +// } +// template<> void RsTypeSerializer::print_data(const std::string& name,BIGNUM * const & /* member */) +// { +// std::cerr << "[BIGNUM] : " << name << std::endl; +// } +// +// 3 - in your service, overload the serialiser declaration to add your own: +// +// MyService::MyService() +// { +// addSerialType(new MyServiceSerializer()) ; +// } +// +// 4 - in your service, recieve and send items by calling recvItem() and sendItem() respectively. +// #include #include #include @@ -12,6 +131,36 @@ class RsItem ; #define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " +class RsSerialType +{ +public: + RsSerialType(uint32_t t); /* only uses top 24bits */ + RsSerialType(uint8_t ver, uint8_t cls, uint8_t t); + RsSerialType(uint8_t ver, uint16_t service); + + virtual ~RsSerialType(); + + virtual uint32_t size(RsItem *)=0; + virtual bool serialise (RsItem *item, void *data, uint32_t *size)=0; + virtual RsItem * deserialise(void *data, uint32_t *size)=0; + + uint32_t PacketId() const; +private: + uint32_t type; +}; + + +class RsRawSerialiser: public RsSerialType +{ + public: + RsRawSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, 0, 0) {} + virtual ~RsRawSerialiser() { } + + virtual uint32_t size(RsItem *); + virtual bool serialise (RsItem *item, void *data, uint32_t *size); + virtual RsItem * deserialise(void *data, uint32_t *size); +}; + class RsGenericSerializer: public RsSerialType { public: @@ -109,4 +258,3 @@ public: - diff --git a/libretroshare/src/serialiser/rsserviceserialiser.cc b/libretroshare/src/serialiser/rsserviceserialiser.cc index 0c953fec3..abdd3e64f 100644 --- a/libretroshare/src/serialiser/rsserviceserialiser.cc +++ b/libretroshare/src/serialiser/rsserviceserialiser.cc @@ -26,78 +26,4 @@ #include "rsitems/rsitem.h" #include "rsserviceserialiser.h" -uint32_t RsServiceSerialiser::size(RsItem *i) -{ - RsRawItem *item = dynamic_cast(i); - - if (item) - { - return item->getRawLength(); - } - return 0; -} - -/* serialise the data to the buffer */ -bool RsServiceSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsRawItem *item = dynamic_cast(i); - if (!item) - { - return false; - } - - #ifdef RSSERIAL_DEBUG - std::cerr << "RsServiceSerialiser::serialise() serializing raw item. pktsize : " << *pktsize; - #endif - - uint32_t tlvsize = item->getRawLength(); - #ifdef RSSERIAL_DEBUG - std::cerr << "tlvsize : " << tlvsize << std::endl; - #endif - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - if (tlvsize > getRsPktMaxSize()) - { - std::cerr << "(EE) Serialised packet is too big. Maximum allowed size is " << getRsPktMaxSize() << ". Serialised size is " << tlvsize << ". Please tune your service to correctly split packets" << std::endl; - return false; /* packet too big */ - } - - *pktsize = tlvsize; - - /* its serialised already!!! */ - memcpy(data, item->getRawData(), tlvsize); - - return true; -} - -RsItem *RsServiceSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - if (RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - if (rssize > getRsPktMaxSize()) - return NULL; /* packet too big */ - - /* set the packet length */ - *pktsize = rssize; - - RsRawItem *item = new RsRawItem(rstype, rssize); - void *item_data = item->getRawData(); - - memcpy(item_data, data, rssize); - - return item; -} - diff --git a/libretroshare/src/serialiser/rsserviceserialiser.h b/libretroshare/src/serialiser/rsserviceserialiser.h index 9bc7d728d..7c00ee3c0 100644 --- a/libretroshare/src/serialiser/rsserviceserialiser.h +++ b/libretroshare/src/serialiser/rsserviceserialiser.h @@ -27,14 +27,4 @@ #include "rsserial.h" -class RsServiceSerialiser: public RsSerialType -{ - public: - RsServiceSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, 0, 0) { } - virtual ~RsServiceSerialiser() { } - - virtual uint32_t size(RsItem *); - virtual bool serialise (RsItem *item, void *data, uint32_t *size); - virtual RsItem * deserialise(void *data, uint32_t *size); -}; diff --git a/libretroshare/src/serialiser/rstypeserializer.cc b/libretroshare/src/serialiser/rstypeserializer.cc index 64ba46f68..fab8c7b2e 100644 --- a/libretroshare/src/serialiser/rstypeserializer.cc +++ b/libretroshare/src/serialiser/rstypeserializer.cc @@ -1,6 +1,5 @@ -#include "serialization/rsserializer.h" -#include "serialization/rstypeserializer.h" - +#include "serialiser/rsserializer.h" +#include "serialiser/rstypeserializer.h" #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvkeys.h" From 24c7c38016efd71f1f1a232c189173ef96250ce2 Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 30 Apr 2017 20:08:30 +0200 Subject: [PATCH 88/94] removed old file rssrviceserialiser.h/cc --- libretroshare/src/libretroshare.pro | 2 -- libretroshare/src/pqi/pqipersongrp.cc | 2 +- libretroshare/src/pqi/pqisslpersongrp.cc | 2 +- libretroshare/src/serialiser/rsserializer.h | 8 ++++- .../src/serialiser/rsserviceserialiser.cc | 29 ------------------ .../src/serialiser/rsserviceserialiser.h | 30 ------------------- 6 files changed, 9 insertions(+), 64 deletions(-) delete mode 100644 libretroshare/src/serialiser/rsserviceserialiser.cc delete mode 100644 libretroshare/src/serialiser/rsserviceserialiser.h diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index f8ea1f6a7..dce14eafd 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -456,7 +456,6 @@ HEADERS += rsitems/rsitem.h \ rsitems/itempriorities.h \ serialiser/rsbaseserial.h \ rsitems/rsfiletransferitems.h \ - serialiser/rsserviceserialiser.h \ rsitems/rsconfigitems.h \ rsitems/rshistoryitems.h \ rsitems/rsmsgitems.h \ @@ -609,7 +608,6 @@ SOURCES += plugins/pluginmanager.cc \ SOURCES += serialiser/rsbaseserial.cc \ rsitems/rsfiletransferitems.cc \ - serialiser/rsserviceserialiser.cc \ rsitems/rsconfigitems.cc \ rsitems/rshistoryitems.cc \ rsitems/rsmsgitems.cc \ diff --git a/libretroshare/src/pqi/pqipersongrp.cc b/libretroshare/src/pqi/pqipersongrp.cc index dd9e645a3..a8afa2b84 100644 --- a/libretroshare/src/pqi/pqipersongrp.cc +++ b/libretroshare/src/pqi/pqipersongrp.cc @@ -27,7 +27,7 @@ #include "pqi/p3linkmgr.h" #include "util/rsdebug.h" #include "util/rsprint.h" -#include "serialiser/rsserviceserialiser.h" +#include "serialiser/rsserializer.h" #include diff --git a/libretroshare/src/pqi/pqisslpersongrp.cc b/libretroshare/src/pqi/pqisslpersongrp.cc index ad6ad098c..3670fb5fe 100644 --- a/libretroshare/src/pqi/pqisslpersongrp.cc +++ b/libretroshare/src/pqi/pqisslpersongrp.cc @@ -23,7 +23,7 @@ * */ -#include "serialiser/rsserviceserialiser.h" +#include "serialiser/rsserializer.h" #include "util/rsdebug.h" #include "pqi/pqisslpersongrp.h" diff --git a/libretroshare/src/serialiser/rsserializer.h b/libretroshare/src/serialiser/rsserializer.h index 639c75806..4559b6582 100644 --- a/libretroshare/src/serialiser/rsserializer.h +++ b/libretroshare/src/serialiser/rsserializer.h @@ -117,7 +117,13 @@ // addSerialType(new MyServiceSerializer()) ; // } // -// 4 - in your service, recieve and send items by calling recvItem() and sendItem() respectively. +// If needed, you may serialize your own items by calling: +// +// uint32_t size = MySerializer().size(item) ; +// uint8_t *data = (uint8_t*)malloc(size); +// MySerializer().serialise(item,data,size) ; +// +// 4 - in your service, receive and send items by calling recvItem() and sendItem() respectively. // #include #include diff --git a/libretroshare/src/serialiser/rsserviceserialiser.cc b/libretroshare/src/serialiser/rsserviceserialiser.cc deleted file mode 100644 index abdd3e64f..000000000 --- a/libretroshare/src/serialiser/rsserviceserialiser.cc +++ /dev/null @@ -1,29 +0,0 @@ -/* - * libretroshare/src/serialiser: rsserviceserialiser.cc - * - * 3P/PQI network interface for RetroShare. - * - * Copyright 2013-2013 by Cyril Soler & Robert Fernie - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License Version 2 as published by the Free Software Foundation. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA. - * - * Please report all bugs and problems to "retroshare@lunamutt.com". - * - */ - -#include "rsitems/rsitem.h" -#include "rsserviceserialiser.h" - - diff --git a/libretroshare/src/serialiser/rsserviceserialiser.h b/libretroshare/src/serialiser/rsserviceserialiser.h deleted file mode 100644 index 7c00ee3c0..000000000 --- a/libretroshare/src/serialiser/rsserviceserialiser.h +++ /dev/null @@ -1,30 +0,0 @@ -/* - * libretroshare/src/serialiser: rsserviceserialiser.h - * - * 3P/PQI network interface for RetroShare. - * - * Copyright 2013-2013 by Cyril Soler & Robert Fernie - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License Version 2 as published by the Free Software Foundation. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA. - * - * Please report all bugs and problems to "retroshare@lunamutt.com". - * - */ - -#pragma once - -#include "rsserial.h" - - From 16b8947af134da32be7a0a33e5bc5efe2d5ebe90 Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 30 Apr 2017 20:31:43 +0200 Subject: [PATCH 89/94] improved serializer documentation --- libretroshare/src/serialiser/rsserializer.cc | 25 ++++++++++++++ libretroshare/src/serialiser/rsserializer.h | 33 +++++++++++++++++++ .../src/serialiser/rstypeserializer.cc | 24 ++++++++++++++ .../src/serialiser/rstypeserializer.h | 24 ++++++++++++++ 4 files changed, 106 insertions(+) diff --git a/libretroshare/src/serialiser/rsserializer.cc b/libretroshare/src/serialiser/rsserializer.cc index ef85008aa..ea6bdd33c 100644 --- a/libretroshare/src/serialiser/rsserializer.cc +++ b/libretroshare/src/serialiser/rsserializer.cc @@ -1,3 +1,28 @@ +/* + * libretroshare/src/serialiser: rsserializer.cc + * + * RetroShare Serialiser. + * + * Copyright 2016 by Cyril Soler + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "csoler@users.sourceforge.net". + * + */ + #include #include "rsitems/rsitem.h" diff --git a/libretroshare/src/serialiser/rsserializer.h b/libretroshare/src/serialiser/rsserializer.h index 4559b6582..4a325fdab 100644 --- a/libretroshare/src/serialiser/rsserializer.h +++ b/libretroshare/src/serialiser/rsserializer.h @@ -1,3 +1,27 @@ +/* + * libretroshare/src/serialiser: rsserializer.h + * + * RetroShare Serialiser. + * + * Copyright 2016 by Cyril Soler + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "csoler@users.sourceforge.net". + * + */ #pragma once /////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -137,6 +161,8 @@ class RsItem ; #define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " +// This is the base class for serializers. + class RsSerialType { public: @@ -155,6 +181,7 @@ private: uint32_t type; }; +// This class is only used internally to p3service. It should not be used explicitely otherwise. class RsRawSerialiser: public RsSerialType { @@ -167,6 +194,8 @@ class RsRawSerialiser: public RsSerialType virtual RsItem * deserialise(void *data, uint32_t *size); }; +// Top class for all services and config serializers. + class RsGenericSerializer: public RsSerialType { public: @@ -226,6 +255,8 @@ protected: }; +// Top class for service serializers. Derive your on service serializer from this class and overload creat_item(). + class RsServiceSerializer: public RsGenericSerializer { public: @@ -243,6 +274,8 @@ public: RsItem *deserialise(void *data,uint32_t *size) ; }; +// Top class for config serializers. Config serializers are only used internally by RS core. The development of new services or plugins do not need this. + class RsConfigSerializer: public RsGenericSerializer { public: diff --git a/libretroshare/src/serialiser/rstypeserializer.cc b/libretroshare/src/serialiser/rstypeserializer.cc index fab8c7b2e..661897b4b 100644 --- a/libretroshare/src/serialiser/rstypeserializer.cc +++ b/libretroshare/src/serialiser/rstypeserializer.cc @@ -1,3 +1,27 @@ +/* + * libretroshare/src/serialiser: rstypeserializer.cc + * + * RetroShare Serialiser. + * + * Copyright 2017 by Cyril Soler + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "csoler@users.sourceforge.net". + * + */ #include "serialiser/rsserializer.h" #include "serialiser/rstypeserializer.h" #include "serialiser/rsbaseserial.h" diff --git a/libretroshare/src/serialiser/rstypeserializer.h b/libretroshare/src/serialiser/rstypeserializer.h index 6ad237be9..333f1a364 100644 --- a/libretroshare/src/serialiser/rstypeserializer.h +++ b/libretroshare/src/serialiser/rstypeserializer.h @@ -1,3 +1,27 @@ +/* + * libretroshare/src/serialiser: rstypeserializer.h + * + * RetroShare Serialiser. + * + * Copyright 2017 by Cyril Soler + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "csoler@users.sourceforge.net". + * + */ #pragma once #include "serialiser/rsserial.h" From 99d8b7d5d8d26f47368857126be49aabc1a1627f Mon Sep 17 00:00:00 2001 From: csoler Date: Mon, 1 May 2017 21:23:34 +0200 Subject: [PATCH 90/94] switched service control items to new serialization --- libretroshare/src/gxs/rsgenexchange.cc | 5 +- libretroshare/src/pqi/p3servicecontrol.cc | 181 ++------------------ libretroshare/src/serialiser/rsserializer.h | 2 +- 3 files changed, 22 insertions(+), 166 deletions(-) diff --git a/libretroshare/src/gxs/rsgenexchange.cc b/libretroshare/src/gxs/rsgenexchange.cc index b946b5931..a970971ff 100644 --- a/libretroshare/src/gxs/rsgenexchange.cc +++ b/libretroshare/src/gxs/rsgenexchange.cc @@ -36,6 +36,7 @@ #include "retroshare/rsgrouter.h" #include "retroshare/rsidentity.h" #include "retroshare/rspeers.h" +#include "rsitems/rsnxsitems.h" #include "rsgixs.h" #include "rsgxsutil.h" #include "rsserver/p3face.h" @@ -1293,7 +1294,7 @@ bool RsGenExchange::getSerializedGroupData(const uint32_t &token, RsGxsGroupId& } RsNxsGrp *nxs_grp = *(nxsGrps.begin()); - size = nxs_grp->serial_size() ; + size = RsNxsSerialiser(mServType).size(nxs_grp); id = nxs_grp->metaData->mGroupId ; if(size > 1024*1024 || NULL==(data = (unsigned char *)rs_malloc(size))) @@ -1303,7 +1304,7 @@ bool RsGenExchange::getSerializedGroupData(const uint32_t &token, RsGxsGroupId& return false ; } - return nxs_grp->serialise(data,size) ; + return RsNxsSerialiser(mServType).serialise(nxs_grp,data,&size) ; } bool RsGenExchange::deserializeGroupData(unsigned char *data,uint32_t size) diff --git a/libretroshare/src/pqi/p3servicecontrol.cc b/libretroshare/src/pqi/p3servicecontrol.cc index d0d9acbdc..3942232c4 100644 --- a/libretroshare/src/pqi/p3servicecontrol.cc +++ b/libretroshare/src/pqi/p3servicecontrol.cc @@ -28,9 +28,8 @@ #include "p3servicecontrol.h" #include "rsitems/rsserviceids.h" #include "rsitems/rsitem.h" -#include "serialiser/rsserial.h" -#include "serialiser/rsbaseserial.h" -#include "serialiser/rsnxsitems.h" +#include "serialiser/rstypeserializer.h" +#include "rsitems/rsnxsitems.h" #include "pqi/p3cfgmgr.h" #include "pqi/pqiservice.h" @@ -44,184 +43,40 @@ class RsServiceControlItem: public RsItem { public: RsServiceControlItem(uint8_t item_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_SERVICE_CONTROL,item_subtype) {} - - virtual uint32_t serial_size() const =0; - virtual bool serialise(uint8_t *data,uint32_t size) const =0; - - bool serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const - { - tlvsize = serial_size() ; - offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsFileTransferItem::serialise_header(): ERROR. Not enough size!" << std::endl; - return false ; - } - #ifdef RSSERIAL_DEBUG - std::cerr << "RsFileItemSerialiser::serialiseData() Header: " << ok << std::endl; - #endif - offset += 8; - - return true ; - } }; + class RsServicePermissionItem: public RsServiceControlItem, public RsServicePermissions { public: - RsServicePermissionItem() - : RsServiceControlItem(RS_PKT_SUBTYPE_SERVICE_CONTROL_SERVICE_PERMISSIONS) {} - RsServicePermissionItem(const RsServicePermissions& perms) - : RsServiceControlItem(RS_PKT_SUBTYPE_SERVICE_CONTROL_SERVICE_PERMISSIONS), - RsServicePermissions(perms) {} + RsServicePermissionItem(): RsServiceControlItem(RS_PKT_SUBTYPE_SERVICE_CONTROL_SERVICE_PERMISSIONS) {} + RsServicePermissionItem(const RsServicePermissions& perms) : RsServiceControlItem(RS_PKT_SUBTYPE_SERVICE_CONTROL_SERVICE_PERMISSIONS), RsServicePermissions(perms) {} - virtual uint32_t serial_size() const + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t s = 8 ; // header + RsTypeSerializer::serial_process(j,ctx,mServiceId,"mServiceId") ; + RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_NAME,mServiceName,"mServiceName") ; + RsTypeSerializer::serial_process (j,ctx,mDefaultAllowed,"mDefaultAllowed") ; - s += 4 ; // mServiceId - s += GetTlvStringSize(mServiceName) ; - s += 1 ; // mDefaultAllowed - s += 4 ; // mPeersAllowed.size() - s += mPeersAllowed.size() * RsPeerId::serial_size() ; - s += 4 ; // mPeersAllowed.size() - s += mPeersDenied.size() * RsPeerId::serial_size() ; - - return s ; - } - virtual bool serialise(uint8_t *data,uint32_t size) const - { - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, mServiceId); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, mServiceName); - ok &= setRawUInt8(data, tlvsize, &offset, mDefaultAllowed); - ok &= setRawUInt32(data, tlvsize, &offset, mPeersAllowed.size()); - - for(std::set::const_iterator it(mPeersAllowed.begin());it!=mPeersAllowed.end();++it) - (*it).serialise(data,tlvsize,offset) ; - - ok &= setRawUInt32(data, tlvsize, &offset, mPeersDenied.size()); - - for(std::set::const_iterator it(mPeersDenied.begin());it!=mPeersDenied.end();++it) - (*it).serialise(data,tlvsize,offset) ; - - if(offset != tlvsize) - { - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelGroupItem() FAIL Size Error! " << std::endl; - ok = false; - } - - if (!ok) - std::cerr << "RsGxsChannelSerialiser::serialiseGxsChannelGroupItem() NOK" << std::endl; - - return ok; - } - - static RsServicePermissionItem *deserialise(uint8_t *data, uint32_t size) - { - RsServicePermissionItem *item = new RsServicePermissionItem ; - - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - if(rssize > size) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - return NULL ; - } - - /* add mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &item->mServiceId); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->mServiceName); - - uint8_t v; - ok &= getRawUInt8(data, rssize, &offset, &v) ; - - if (v != 0 && v != 1) - ok = false; - else - item->mDefaultAllowed = (bool)v ; - - uint32_t tmp ; - ok &= getRawUInt32(data, rssize, &offset, &tmp); - - for(uint32_t i=0;imPeersAllowed.insert(peer_id) ; - } - - ok &= getRawUInt32(data, rssize, &offset, &tmp); - - for(uint32_t i=0;imPeersDenied.insert(peer_id) ; - } - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete(item); - return NULL ; - } - - return item; + RsTypeSerializer::serial_process (j,ctx,mPeersAllowed,"mPeersAllowed"); + RsTypeSerializer::serial_process (j,ctx,mPeersDenied ,"mPeersDenied"); } virtual void clear() {} - virtual std::ostream& print(std::ostream& out,uint16_t) - { - std::cerr << __PRETTY_FUNCTION__ << ": not implemented!" << std::endl; - return out ; - } }; -class ServiceControlSerialiser: public RsSerialType +class ServiceControlSerialiser: public RsServiceSerializer { public: - ServiceControlSerialiser() : RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICE_CONTROL) {} + ServiceControlSerialiser() : RsServiceSerializer(RS_SERVICE_TYPE_SERVICE_CONTROL) {} - virtual uint32_t size (RsItem *item) + virtual RsItem *create_item(uint16_t service,uint8_t item_subtype) const { - RsServiceControlItem *scitem = dynamic_cast(item); - if (!scitem) - { - return 0; - } - return scitem->serial_size() ; - } - virtual bool serialise(RsItem *item, void *data, uint32_t *size) - { - RsServiceControlItem *scitem = dynamic_cast(item); - if (!scitem) - { - return false; - } - return scitem->serialise((uint8_t*)data,*size) ; - } - virtual RsItem *deserialise (void *data, uint32_t *size) - { - uint32_t rstype = getRsItemId(data); + if(RS_SERVICE_TYPE_SERVICE_CONTROL != service) + return NULL; - if(RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype) || RS_SERVICE_TYPE_SERVICE_CONTROL != getRsItemService(rstype)) { return NULL; /* wrong type */ } - - switch(getRsItemSubType(rstype)) + switch(item_subtype) { - case RS_PKT_SUBTYPE_SERVICE_CONTROL_SERVICE_PERMISSIONS:return RsServicePermissionItem::deserialise((uint8_t*)data, *size); + case RS_PKT_SUBTYPE_SERVICE_CONTROL_SERVICE_PERMISSIONS: return new RsServicePermissionItem(); default: return NULL ; } diff --git a/libretroshare/src/serialiser/rsserializer.h b/libretroshare/src/serialiser/rsserializer.h index 4a325fdab..c9f1f6403 100644 --- a/libretroshare/src/serialiser/rsserializer.h +++ b/libretroshare/src/serialiser/rsserializer.h @@ -60,7 +60,7 @@ // { // MyServiceSerializer() : RsServiceSerializer(MY_SERVICE_IDENTIFIER) {} // -// RsItem *create_item(uint16_t service,uint8_t item_subtype) +// RsItem *create_item(uint16_t service,uint8_t item_subtype) const // mind the "const"! // { // if(service != MY_SERVICE_IDENTIFIER) return NULL ; // From 861dc165f70e200a3184e84f39c6eae74e9383a9 Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 2 May 2017 22:05:54 +0200 Subject: [PATCH 91/94] switched VOIP to new serialization --- plugins/FeedReader/services/p3FeedReader.cc | 2 +- plugins/VOIP/services/p3VOIP.cc | 2 +- plugins/VOIP/services/p3VOIP.h | 2 +- plugins/VOIP/services/rsVOIPItems.cc | 529 ++------------------ plugins/VOIP/services/rsVOIPItems.h | 63 +-- 5 files changed, 52 insertions(+), 546 deletions(-) diff --git a/plugins/FeedReader/services/p3FeedReader.cc b/plugins/FeedReader/services/p3FeedReader.cc index f4f287790..efa3b6688 100644 --- a/plugins/FeedReader/services/p3FeedReader.cc +++ b/plugins/FeedReader/services/p3FeedReader.cc @@ -22,7 +22,7 @@ #include "rsFeedReaderItems.h" #include "p3FeedReader.h" #include "p3FeedReaderThread.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "retroshare/rsiface.h" #include "retroshare/rsgxsforums.h" #include "util/rsstring.h" diff --git a/plugins/VOIP/services/p3VOIP.cc b/plugins/VOIP/services/p3VOIP.cc index b2c3f27bf..4921fe0cc 100644 --- a/plugins/VOIP/services/p3VOIP.cc +++ b/plugins/VOIP/services/p3VOIP.cc @@ -25,7 +25,7 @@ #include "pqi/pqistore.h" #include "pqi/p3linkmgr.h" #include -#include +#include #include // for std::istringstream diff --git a/plugins/VOIP/services/p3VOIP.h b/plugins/VOIP/services/p3VOIP.h index 961496019..4be04af12 100644 --- a/plugins/VOIP/services/p3VOIP.h +++ b/plugins/VOIP/services/p3VOIP.h @@ -27,7 +27,7 @@ #include "services/rsVOIPItems.h" #include "services/p3service.h" #include "serialiser/rstlvbase.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsconfigitems.h" #include "plugins/rspqiservice.h" #include diff --git a/plugins/VOIP/services/rsVOIPItems.cc b/plugins/VOIP/services/rsVOIPItems.cc index cd3132dfd..cf4aefed7 100644 --- a/plugins/VOIP/services/rsVOIPItems.cc +++ b/plugins/VOIP/services/rsVOIPItems.cc @@ -20,8 +20,7 @@ ****************************************************************/ #include -#include "serialiser/rsbaseserial.h" -#include "serialiser/rstlvbase.h" +#include "serialiser/rstypeserializer.h" #include "services/rsVOIPItems.h" @@ -31,505 +30,47 @@ #include -/*************************************************************************/ - -std::ostream& RsVOIPPingItem::print(std::ostream &out, uint16_t indent) +RsItem *RsVOIPSerialiser::create_item(uint16_t service,uint8_t item_subtype) const { - printRsItemBase(out, "RsVOIPPingItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "SeqNo: " << mSeqNo << std::endl; - - printIndent(out, int_Indent); - out << "PingTS: " << std::hex << mPingTS << std::dec << std::endl; - - printRsItemEnd(out, "RsVOIPPingItem", indent); - return out; -} - -std::ostream& RsVOIPPongItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsVOIPPongItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "SeqNo: " << mSeqNo << std::endl; - - printIndent(out, int_Indent); - out << "PingTS: " << std::hex << mPingTS << std::dec << std::endl; - - printIndent(out, int_Indent); - out << "PongTS: " << std::hex << mPongTS << std::dec << std::endl; - - printRsItemEnd(out, "RsVOIPPongItem", indent); - return out; -} -std::ostream& RsVOIPProtocolItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsVOIPProtocolItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "flags: " << flags << std::endl; - - printIndent(out, int_Indent); - out << "protocol: " << std::hex << (uint32_t)protocol << std::dec << std::endl; - - printRsItemEnd(out, "RsVOIPProtocolItem", indent); - return out; -} -std::ostream& RsVOIPBandwidthItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsVOIPBandwidthItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "flags: " << std::hex << flags << std::dec << std::endl; - - printIndent(out, int_Indent); - out << "speed: " << bytes_per_sec << std::endl; - - printRsItemEnd(out, "RsVOIPBandwidthItem", indent); - return out; -} -std::ostream& RsVOIPDataItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsVOIPDataItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "flags: " << flags << std::endl; - - printIndent(out, int_Indent); - out << "data size: " << std::hex << data_size << std::dec << std::endl; - - printRsItemEnd(out, "RsVOIPDataItem", indent); - return out; -} - -/*************************************************************************/ -uint32_t RsVOIPDataItem::serial_size() const -{ - uint32_t s = 8; /* header */ - s += 4; /* flags */ - s += 4; /* data_size */ - s += data_size; /* data */ - - return s; -} -uint32_t RsVOIPBandwidthItem::serial_size() const -{ - uint32_t s = 8; /* header */ - s += 4; /* flags */ - s += 4; /* bandwidth */ - - return s; -} -uint32_t RsVOIPProtocolItem::serial_size() const -{ - uint32_t s = 8; /* header */ - s += 4; /* flags */ - s += 4; /* protocol */ - - return s; -} -uint32_t RsVOIPPingItem::serial_size() const -{ - uint32_t s = 8; /* header */ - s += 4; /* seqno */ - s += 8; /* pingTS */ - - return s; -} -bool RsVOIPProtocolItem::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); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsVOIPSerialiser::serialiseVOIPDataItem() Header: " << ok << std::endl; - std::cerr << "RsVOIPSerialiser::serialiseVOIPDataItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, (uint32_t)protocol); - ok &= setRawUInt32(data, tlvsize, &offset, flags); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsVOIPSerialiser::serialiseVOIPPingItem() Size Error! " << std::endl; - } - - return ok; -} -bool RsVOIPBandwidthItem::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); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsVOIPSerialiser::serialiseVOIPBandwidthItem() Header: " << ok << std::endl; - std::cerr << "RsVOIPSerialiser::serialiseVOIPBandwidthItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, flags); - ok &= setRawUInt32(data, tlvsize, &offset, bytes_per_sec); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsVOIPSerialiser::serialiseVOIPBandwidthItem() Size Error! " << std::endl; - } - - return ok; -} -/* serialise the data to the buffer */ -bool RsVOIPDataItem::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); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsVOIPSerialiser::serialiseVOIPDataItem() Header: " << ok << std::endl; - std::cerr << "RsVOIPSerialiser::serialiseVOIPDataItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, flags); - ok &= setRawUInt32(data, tlvsize, &offset, data_size); - - memcpy( &((uint8_t*)data)[offset],voip_data,data_size) ; - offset += data_size ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsVOIPSerialiser::serialiseVOIPPingItem() Size Error! " << std::endl; - } - - return ok; -} -/* serialise the data to the buffer */ -bool RsVOIPPingItem::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); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsVOIPSerialiser::serialiseVOIPPingItem() Header: " << ok << std::endl; - std::cerr << "RsVOIPSerialiser::serialiseVOIPPingItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, mSeqNo); - ok &= setRawUInt64(data, tlvsize, &offset, mPingTS); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsVOIPSerialiser::serialiseVOIPPingItem() Size Error! " << std::endl; - } - - return ok; -} - -RsVOIPProtocolItem::RsVOIPProtocolItem(void *data, uint32_t pktsize) - : RsVOIPItem(RS_PKT_SUBTYPE_VOIP_PROTOCOL) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_VOIP_PLUGIN != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_VOIP_PROTOCOL != getRsItemSubType(rstype))) - throw std::runtime_error("Wrong packet type!") ; - - if (pktsize < rssize) /* check size */ - throw std::runtime_error("Not enough size!") ; - - bool ok = true; - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - uint32_t uint_Protocol; - ok &= getRawUInt32(data, rssize, &offset, &uint_Protocol); - protocol = static_cast(uint_Protocol); - ok &= getRawUInt32(data, rssize, &offset, &flags); - - if (offset != rssize) - throw std::runtime_error("Deserialisation error!") ; - - if (!ok) - throw std::runtime_error("Deserialisation error!") ; -} -RsVOIPBandwidthItem::RsVOIPBandwidthItem(void *data, uint32_t pktsize) - : RsVOIPItem(RS_PKT_SUBTYPE_VOIP_BANDWIDTH) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_VOIP_PLUGIN != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_VOIP_BANDWIDTH != getRsItemSubType(rstype))) - throw std::runtime_error("Wrong packet type!") ; - - if (pktsize < rssize) /* check size */ - throw std::runtime_error("Not enough size!") ; - - bool ok = true; - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &flags); - ok &= getRawUInt32(data, rssize, &offset, &bytes_per_sec); - - if (offset != rssize) - throw std::runtime_error("Deserialisation error!") ; - - if (!ok) - throw std::runtime_error("Deserialisation error!") ; -} -RsVOIPPingItem::RsVOIPPingItem(void *data, uint32_t pktsize) - : RsVOIPItem(RS_PKT_SUBTYPE_VOIP_PING) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_VOIP_PLUGIN != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_VOIP_PING != getRsItemSubType(rstype))) - throw std::runtime_error("Wrong packet type!") ; - - if (pktsize < rssize) /* check size */ - throw std::runtime_error("Not enough size!") ; - - bool ok = true; - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &mSeqNo); - ok &= getRawUInt64(data, rssize, &offset, &mPingTS); - - if (offset != rssize) - throw std::runtime_error("Deserialisation error!") ; - - if (!ok) - throw std::runtime_error("Deserialisation error!") ; -} - -/*************************************************************************/ -/*************************************************************************/ - - -uint32_t RsVOIPPongItem::serial_size() const -{ - uint32_t s = 8; /* header */ - s += 4; /* seqno */ - s += 8; /* pingTS */ - s += 8; /* pongTS */ - - return s; -} - -/* serialise the data to the buffer */ -bool RsVOIPPongItem::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); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsVOIPSerialiser::serialiseVOIPPongItem() Header: " << ok << std::endl; - std::cerr << "RsVOIPSerialiser::serialiseVOIPPongItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, mSeqNo); - ok &= setRawUInt64(data, tlvsize, &offset, mPingTS); - ok &= setRawUInt64(data, tlvsize, &offset, mPongTS); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsVOIPSerialiser::serialiseVOIPPongItem() Size Error! " << std::endl; - } - - return ok; -} -RsVOIPDataItem::RsVOIPDataItem(void *data, uint32_t pktsize) - : RsVOIPItem(RS_PKT_SUBTYPE_VOIP_DATA) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_VOIP_PLUGIN != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_VOIP_DATA != getRsItemSubType(rstype))) - throw std::runtime_error("Wrong packet subtype") ; - - if (pktsize < rssize) /* check size */ - throw std::runtime_error("Not enough space") ; - - bool ok = true; - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &flags); - ok &= getRawUInt32(data, rssize, &offset, &data_size); - - if(data_size > rssize || rssize - data_size < offset) - throw std::runtime_error("Not enough space.") ; - - voip_data = rs_malloc(data_size) ; - - if(!voip_data) - throw std::runtime_error("Serialization error.") ; - - memcpy(voip_data,&((uint8_t*)data)[offset],data_size) ; - offset += data_size ; - - if (offset != rssize) - throw std::runtime_error("Serialization error.") ; - - if (!ok) - throw std::runtime_error("Serialization error.") ; -} -RsVOIPPongItem::RsVOIPPongItem(void *data, uint32_t pktsize) - : RsVOIPItem(RS_PKT_SUBTYPE_VOIP_PONG) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_VOIP_PLUGIN != getRsItemService(rstype)) || (RS_PKT_SUBTYPE_VOIP_PONG != getRsItemSubType(rstype))) - throw std::runtime_error("Wrong packet subtype") ; - - if (pktsize < rssize) /* check size */ - throw std::runtime_error("Not enough space") ; - - bool ok = true; - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &mSeqNo); - ok &= getRawUInt64(data, rssize, &offset, &mPingTS); - ok &= getRawUInt64(data, rssize, &offset, &mPongTS); - - if (offset != rssize) - throw std::runtime_error("Serialization error.") ; - - if (!ok) - throw std::runtime_error("Serialization error.") ; -} - -/*************************************************************************/ - -RsItem* RsVOIPSerialiser::deserialise(void *data, uint32_t *pktsize) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsVOIPSerialiser::deserialise()" << std::endl; -#endif - - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_VOIP_PLUGIN != getRsItemService(rstype))) + if(service != RS_SERVICE_TYPE_VOIP_PLUGIN) return NULL ; - - try - { - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_VOIP_PING: return new RsVOIPPingItem(data, *pktsize); - case RS_PKT_SUBTYPE_VOIP_PONG: return new RsVOIPPongItem(data, *pktsize); - case RS_PKT_SUBTYPE_VOIP_PROTOCOL: return new RsVOIPProtocolItem(data, *pktsize); - case RS_PKT_SUBTYPE_VOIP_DATA: return new RsVOIPDataItem(data, *pktsize); - default: - return NULL; - } - } - catch(std::exception& e) + switch(item_subtype) { - std::cerr << "RsVOIPSerialiser: deserialization error: " << e.what() << std::endl; - return NULL; + case RS_PKT_SUBTYPE_VOIP_PING: return new RsVOIPPingItem(); + case RS_PKT_SUBTYPE_VOIP_PONG: return new RsVOIPPongItem(); + case RS_PKT_SUBTYPE_VOIP_PROTOCOL: return new RsVOIPProtocolItem(); + case RS_PKT_SUBTYPE_VOIP_DATA: return new RsVOIPDataItem(); + default: + return NULL ; } } +void RsVOIPProtocolItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,protocol,"protocol") ; + RsTypeSerializer::serial_process(j,ctx,flags ,"flags") ; +} + +void RsVOIPPingItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mSeqNo,"mSeqNo") ; + RsTypeSerializer::serial_process(j,ctx,mPingTS,"mPingTS") ; +} +void RsVOIPPongItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mSeqNo,"mSeqNo") ; + RsTypeSerializer::serial_process(j,ctx,mPingTS,"mPingTS") ; + RsTypeSerializer::serial_process(j,ctx,mPongTS,"mPongTS") ; +} +void RsVOIPDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,flags ,"flags") ; + + RsTypeSerializer::TlvMemBlock_proxy prox((uint8_t*&)voip_data,data_size) ; + + RsTypeSerializer::serial_process(j,ctx,prox,"data") ; +} /*************************************************************************/ diff --git a/plugins/VOIP/services/rsVOIPItems.h b/plugins/VOIP/services/rsVOIPItems.h index a685f9ef6..222412853 100644 --- a/plugins/VOIP/services/rsVOIPItems.h +++ b/plugins/VOIP/services/rsVOIPItems.h @@ -49,7 +49,7 @@ #include #include "rsitems/rsserviceids.h" -#include "serialiser/rsserial.h" +#include "rsitems/rsitem.h" /**************************************************************************/ @@ -70,31 +70,22 @@ const uint32_t RS_VOIP_FLAGS_AUDIO_DATA = 0x0002 ; class RsVOIPItem: public RsItem { public: - RsVOIPItem(uint8_t voip_subtype) - : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_VOIP_PLUGIN,voip_subtype) + RsVOIPItem(uint8_t voip_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_VOIP_PLUGIN,voip_subtype) { setPriorityLevel(QOS_PRIORITY_RS_VOIP) ; } virtual ~RsVOIPItem() {} virtual void clear() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0 ; - - virtual bool serialise(void *data,uint32_t& size) = 0 ; // Isn't it better that items can serialise themselves ? - virtual uint32_t serial_size() const = 0 ; // deserialise is handled using a constructor }; class RsVOIPPingItem: public RsVOIPItem { public: RsVOIPPingItem() :RsVOIPItem(RS_PKT_SUBTYPE_VOIP_PING), mSeqNo(0), mPingTS(0) {} - RsVOIPPingItem(void *data,uint32_t size) ; - - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() const ; - virtual ~RsVOIPPingItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t mSeqNo; uint64_t mPingTS; @@ -104,17 +95,13 @@ class RsVOIPDataItem: public RsVOIPItem { public: RsVOIPDataItem() :RsVOIPItem(RS_PKT_SUBTYPE_VOIP_DATA) {} - RsVOIPDataItem(void *data,uint32_t size) ; // de-serialization - - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() const ; virtual ~RsVOIPDataItem() { free(voip_data) ; voip_data = NULL ; } - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t flags ; uint32_t data_size ; @@ -122,37 +109,31 @@ class RsVOIPDataItem: public RsVOIPItem void *voip_data ; }; +#ifdef TODO class RsVOIPBandwidthItem: public RsVOIPItem { public: RsVOIPBandwidthItem() :RsVOIPItem(RS_PKT_SUBTYPE_VOIP_BANDWIDTH) {} - RsVOIPBandwidthItem(void *data,uint32_t size) ; // de-serialization - - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() const ; virtual ~RsVOIPBandwidthItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t flags ; // is that incoming or expected bandwidth? uint32_t bytes_per_sec ; // bandwidth in bytes per sec. }; +#endif class RsVOIPProtocolItem: public RsVOIPItem { public: RsVOIPProtocolItem() :RsVOIPItem(RS_PKT_SUBTYPE_VOIP_PROTOCOL) {} - RsVOIPProtocolItem(void *data,uint32_t size) ; typedef enum { VoipProtocol_Ring = 1, VoipProtocol_Ackn = 2, VoipProtocol_Close = 3, VoipProtocol_Bandwidth = 4 } en_Protocol; - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() const ; - virtual ~RsVOIPProtocolItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); - en_Protocol protocol ; + uint32_t protocol ; uint32_t flags ; }; @@ -160,38 +141,22 @@ class RsVOIPPongItem: public RsVOIPItem { public: RsVOIPPongItem() :RsVOIPItem(RS_PKT_SUBTYPE_VOIP_PONG) {} - RsVOIPPongItem(void *data,uint32_t size) ; - - virtual bool serialise(void *data,uint32_t& size) ; - virtual uint32_t serial_size() const ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); virtual ~RsVOIPPongItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); uint32_t mSeqNo; uint64_t mPingTS; uint64_t mPongTS; }; -class RsVOIPSerialiser: public RsSerialType +class RsVOIPSerialiser: public RsServiceSerializer { public: - RsVOIPSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_VOIP_PLUGIN) - { - } + RsVOIPSerialiser() :RsServiceSerializer(RS_SERVICE_TYPE_VOIP_PLUGIN) {} virtual ~RsVOIPSerialiser() {} - virtual uint32_t size (RsItem *item) - { - return dynamic_cast(item)->serial_size() ; - } - - virtual bool serialise (RsItem *item, void *data, uint32_t *size) - { - return dynamic_cast(item)->serialise(data,*size) ; - } - virtual RsItem *deserialise(void *data, uint32_t *size); + virtual RsItem *create_item(uint16_t service,uint8_t item_subtype) const ; }; /**************************************************************************/ From 4bee52c406de7cf6a3c11f97d73f4e5da678861d Mon Sep 17 00:00:00 2001 From: csoler Date: Tue, 2 May 2017 22:34:45 +0200 Subject: [PATCH 92/94] removed old unused serialization code --- libretroshare/src/grouter/grouteritems.cc | 822 ------------ libretroshare/src/grouter/p3grouter.cc | 20 - .../src/gxstunnel/rsgxstunnelitems.cc | 459 ------- libretroshare/src/pqi/p3peermgr.cc | 38 - libretroshare/src/rsitems/rsbwctrlitems.cc | 138 -- libretroshare/src/rsitems/rsconfigitems.h | 89 -- .../src/rsitems/rsgxscommentitems.cc | 389 ------ libretroshare/src/rsitems/rsgxsiditems.cc | 616 --------- libretroshare/src/rsitems/rsgxsrecognitems.cc | 548 -------- .../src/rsitems/rsgxsreputationitems.cc | 519 ------- libretroshare/src/rsitems/rshistoryitems.cc | 221 --- libretroshare/src/rsitems/rsnxsitems.cc | 1195 ----------------- libretroshare/src/rsitems/rsrttitems.cc | 334 ----- libretroshare/src/rsitems/rswikiitems.cc | 543 -------- libretroshare/src/rsitems/rswireitems.cc | 379 ------ 15 files changed, 6310 deletions(-) diff --git a/libretroshare/src/grouter/grouteritems.cc b/libretroshare/src/grouter/grouteritems.cc index c856132db..5fc4813a7 100644 --- a/libretroshare/src/grouter/grouteritems.cc +++ b/libretroshare/src/grouter/grouteritems.cc @@ -67,81 +67,11 @@ void RsGRouterTransactionChunkItem::serial_process(RsGenericSerializer::Serializ std::cerr << " [Binary data] " << ", length=" << chunk_size << " data=" << RsUtil::BinToHex((uint8_t*)chunk_data,std::min(50u,chunk_size)) << ((chunk_size>50)?"...":"") << std::endl; } -#ifdef TO_REMOVE -RsGRouterTransactionChunkItem *RsGRouterSerialiser::deserialise_RsGRouterTransactionChunkItem(void *data, uint32_t tlvsize) const -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - if(tlvsize < rssize) - { - std::cerr << __PRETTY_FUNCTION__ << ": wrong encoding of item size. Serialisation error!" << std::endl; - return NULL ; - } - - RsGRouterTransactionChunkItem *item = new RsGRouterTransactionChunkItem() ; - - /* add mandatory parts first */ - ok &= getRawUInt64(data, tlvsize, &offset, &item->propagation_id); - ok &= getRawUInt32(data, tlvsize, &offset, &item->chunk_start); - ok &= getRawUInt32(data, tlvsize, &offset, &item->chunk_size); - ok &= getRawUInt32(data, tlvsize, &offset, &item->total_size); - - if(item->chunk_size > rssize || offset > rssize - item->chunk_size) // better than if(item->chunk_size + offset > rssize) - { - std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl; - delete item; - return NULL ; - } - if( NULL == (item->chunk_data = (uint8_t*)rs_malloc(item->chunk_size))) - { - delete item; - return NULL ; - } - - memcpy(item->chunk_data,&((uint8_t*)data)[offset],item->chunk_size) ; - offset += item->chunk_size ; - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -#endif - void RsGRouterTransactionAcknItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,propagation_id,"propagation_id") ; } -#ifdef TO_REMOVE -RsGRouterTransactionAcknItem *RsGRouterSerialiser::deserialise_RsGRouterTransactionAcknItem(void *data, uint32_t tlvsize) const -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGRouterTransactionAcknItem *item = new RsGRouterTransactionAcknItem() ; - - /* add mandatory parts first */ - ok &= getRawUInt64(data, tlvsize, &offset, &item->propagation_id); - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -#endif - void RsGRouterGenericDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,routing_id,"routing_id") ; @@ -174,76 +104,6 @@ void RsGRouterGenericDataItem::serial_process(RsGenericSerializer::SerializeJob } } -#ifdef TO_REMOVE -RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *data, uint32_t pktsize) const -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - if(pktsize < rssize) - { - std::cerr << __PRETTY_FUNCTION__ << ": wrong encoding of item size. Serialisation error!" << std::endl; - return NULL ; - } - RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem() ; - - ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id); - ok &= item->destination_key.deserialise(data, pktsize, offset) ; - ok &= getRawUInt32(data, pktsize, &offset, &item->service_id); - ok &= getRawUInt32(data, pktsize, &offset, &item->data_size); - - if(item->data_size > 0) // This happens when the item data has been deleted from the cache - { - if(item->data_size > rssize || offset > rssize - item->data_size) // better than if(item->data_size + offset > rssize) - { - std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl; - delete item; - return NULL ; - } - - if( NULL == (item->data_bytes = (uint8_t*)rs_malloc(item->data_size))) - { - delete item; - return NULL ; - } - - memcpy(item->data_bytes,&((uint8_t*)data)[offset],item->data_size) ; - offset += item->data_size ; - } - else - item->data_bytes = NULL ; - - ok &= item->signature.GetTlv(data, pktsize, &offset) ; - - ok &= getRawUInt32(data, pktsize, &offset, &item->duplication_factor); - - // make sure the duplication factor is not altered by friends. In the worst case, the item will duplicate a bit more. - - if(item->duplication_factor < 1) - { - item->duplication_factor = 1 ; - std::cerr << "(II) correcting GRouter item duplication factor from 0 to 1, to ensure backward compat." << std::endl; - } - if(item->duplication_factor > GROUTER_MAX_DUPLICATION_FACTOR) - { - std::cerr << "(WW) correcting GRouter item duplication factor of " << item->duplication_factor << ". This is very unexpected." << std::endl; - item->duplication_factor = GROUTER_MAX_DUPLICATION_FACTOR ; - } - - ok &= getRawUInt32(data, pktsize, &offset, &item->flags); - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -#endif - void RsGRouterSignedReceiptItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,routing_id,"routing_id") ; @@ -258,33 +118,6 @@ void RsGRouterSignedReceiptItem::serial_process(RsGenericSerializer::SerializeJo RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; } -#ifdef TO_REMOVE -RsGRouterSignedReceiptItem *RsGRouterSerialiser::deserialise_RsGRouterSignedReceiptItem(void *data, uint32_t pktsize) const -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGRouterSignedReceiptItem *item = new RsGRouterSignedReceiptItem() ; - - ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id); - ok &= getRawUInt32(data, pktsize, &offset, &item->flags); - ok &= item->destination_key.deserialise(data, pktsize, offset); - ok &= getRawUInt32(data, pktsize, &offset, &item->service_id); - ok &= item->data_hash.deserialise(data, pktsize, offset); - ok &= item->signature.GetTlv(data, pktsize, &offset); // signature - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -#endif - void RsGRouterRoutingInfoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,peerId,"peerId") ; @@ -352,99 +185,11 @@ void RsGRouterRoutingInfoItem::serial_process(RsGenericSerializer::SerializeJob } } -#ifdef TO_REMOVE -RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *data, uint32_t pktsize) const -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGRouterRoutingInfoItem *item = new RsGRouterRoutingInfoItem() ; - - RsPeerId peer_id ; - ok &= peer_id.deserialise(data, pktsize, offset) ; - item->PeerId(peer_id) ; - - ok &= getRawUInt32(data, pktsize, &offset, &item->data_status); - ok &= getRawUInt32(data, pktsize, &offset, &item->tunnel_status); - ok &= getRawTimeT(data, pktsize, &offset, item->received_time_TS); - ok &= getRawTimeT(data, pktsize, &offset, item->last_sent_TS); - - ok &= getRawTimeT(data, pktsize, &offset, item->last_tunnel_request_TS); - ok &= getRawUInt32(data, pktsize, &offset, &item->sending_attempts); - - ok &= getRawUInt32(data, pktsize, &offset, &item->client_id); - ok &= item->item_hash.deserialise(data, pktsize, offset) ; - ok &= item->tunnel_hash.deserialise(data, pktsize, offset) ; - ok &= getRawUInt32(data, pktsize, &offset, &item->routing_flags) ; - - ok &= item->incoming_routes.GetTlv(data,pktsize,&offset) ; - - item->data_item = deserialise_RsGRouterGenericDataItem(&((uint8_t*)data)[offset],pktsize - offset) ; - if(item->data_item != NULL) - offset += item->data_item->serial_size() ; - else - ok = false ; - - // Receipt item is optional. - - if (offset < pktsize) - { // - item->receipt_item = deserialise_RsGRouterSignedReceiptItem(&((uint8_t*)data)[offset],pktsize - offset); - if (item->receipt_item != NULL) - offset += item->receipt_item->serial_size(); - else // - ok = false; - } - else // - item->receipt_item = NULL; - - - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -#endif - void RsGRouterMatrixFriendListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,reverse_friend_indices,"reverse_friend_indices") ; } -#ifdef TO_REMOVE -RsGRouterMatrixFriendListItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(void *data, uint32_t pktsize) const -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGRouterMatrixFriendListItem *item = new RsGRouterMatrixFriendListItem() ; - - uint32_t nb_friends = 0 ; - ok &= getRawUInt32(data, pktsize, &offset, &nb_friends); // file hash - - item->reverse_friend_indices.resize(nb_friends) ; - - for(uint32_t i=0;ok && ireverse_friend_indices[i].deserialise(data, pktsize, offset) ; - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -#endif - void RsGRouterMatrixTrackItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,provider_id,"provider_id") ; @@ -452,30 +197,6 @@ void RsGRouterMatrixTrackItem::serial_process(RsGenericSerializer::SerializeJob RsTypeSerializer::serial_process(j,ctx,time_stamp,"time_stamp") ; } -#ifdef TO_REMOVE -RsGRouterMatrixTrackItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixTrackItem(void *data, uint32_t pktsize) const -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGRouterMatrixTrackItem *item = new RsGRouterMatrixTrackItem() ; - - ok &= item->provider_id.deserialise(data, pktsize, offset) ; - ok &= item->message_id.deserialise(data,pktsize,offset) ; - ok &= getRawTimeT(data, pktsize, &offset, item->time_stamp) ; - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -#endif - void RsGRouterMatrixCluesItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,destination_key,"destination_key") ; @@ -489,44 +210,6 @@ template<> void RsTypeSerializer::serial_process(RsGenericSerializer::SerializeJ RsTypeSerializer::serial_process (j,ctx,s.time_stamp,name+":time_stamp") ; } -#ifdef TO_REMOVE -RsGRouterMatrixCluesItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesItem(void *data, uint32_t pktsize) const -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGRouterMatrixCluesItem *item = new RsGRouterMatrixCluesItem() ; - - ok &= item->destination_key.deserialise(data,pktsize,offset) ; - - uint32_t nb_clues = 0 ; - ok &= getRawUInt32(data, pktsize, &offset, &nb_clues); - - item->clues.clear() ; - - for(uint32_t j=0;jclues.push_back(HitE) ; - } - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -#endif - RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const { RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem ; @@ -565,508 +248,3 @@ RsGRouterSignedReceiptItem *RsGRouterSignedReceiptItem::duplicate() const return item ; } -#ifdef TO_REMOVE -uint32_t RsGRouterGenericDataItem::serial_size() const -{ - uint32_t s = 8 ; // header - s += sizeof(GRouterMsgPropagationId) ; // routing id - s += destination_key.serial_size() ; // destination_key - s += 4 ; // data_size - s += 4 ; // service id - s += data_size ; // data - s += signature.TlvSize() ; // signature - s += 4 ; // duplication_factor - s += 4 ; // flags - - return s ; -} -uint32_t RsGRouterGenericDataItem::signed_data_size() const -{ - uint32_t s = 0 ; // no header - s += sizeof(GRouterMsgPropagationId) ; // routing id - s += destination_key.serial_size() ; // destination_key - s += 4 ; // data_size - s += 4 ; // service id - s += data_size ; // data - - return s ; -} -uint32_t RsGRouterSignedReceiptItem::serial_size() const -{ - uint32_t s = 8 ; // header - s += sizeof(GRouterMsgPropagationId) ; // routing id - s += destination_key.serial_size() ; // destination_key - s += data_hash.serial_size() ; - s += 4 ; // state - s += 4 ; // service_id - s += signature.TlvSize() ; // signature - - return s ; -} -uint32_t RsGRouterSignedReceiptItem::signed_data_size() const -{ - uint32_t s = 0 ; // no header - s += sizeof(GRouterMsgPropagationId) ; // routing id - s += destination_key.serial_size() ; // destination_key - s += data_hash.serial_size() ; - s += 4 ; // service_id - s += 4 ; // state - - return s ; -} -uint32_t RsGRouterTransactionChunkItem::serial_size() const -{ - uint32_t s = 8 ; // header - s += sizeof(GRouterMsgPropagationId) ; // routing id - s += 4 ; // chunk_start - s += 4 ; // chunk_size - s += 4 ; // total_size - s += chunk_size ; // data - - return s; -} -uint32_t RsGRouterTransactionAcknItem::serial_size() const -{ - uint32_t s = 8 ; // header - s += sizeof(GRouterMsgPropagationId) ; // routing id - - return s; -} -bool RsGRouterTransactionChunkItem::serialise(void *data,uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, propagation_id); - ok &= setRawUInt32(data, tlvsize, &offset, chunk_start); - ok &= setRawUInt32(data, tlvsize, &offset, chunk_size); - ok &= setRawUInt32(data, tlvsize, &offset, total_size); - - memcpy(&((uint8_t*)data)[offset],chunk_data,chunk_size) ; - offset += chunk_size ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -bool RsGRouterGenericDataItem::serialise(void *data,uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, routing_id); - ok &= destination_key.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, service_id); - ok &= setRawUInt32(data, tlvsize, &offset, data_size); - - memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ; - offset += data_size ; - - ok &= signature.SetTlv(data, tlvsize, &offset) ; - - ok &= setRawUInt32(data, tlvsize, &offset, duplication_factor) ; - ok &= setRawUInt32(data, tlvsize, &offset, flags) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -bool RsGRouterTransactionAcknItem::serialise(void *data,uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, propagation_id); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -bool RsGRouterGenericDataItem::serialise_signed_data(void *data,uint32_t size) const -{ - bool ok = true; - - uint32_t offset = 0; - uint32_t tlvsize = signed_data_size() ; - - if(tlvsize > size) - { - ok = false; - std::cerr << "RsGRouterReceiptItem::serialisedata() size error! Not enough size in supplied container." << std::endl; - } - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, routing_id); - ok &= destination_key.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, service_id); - ok &= setRawUInt32(data, tlvsize, &offset, data_size); - - memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ; - offset += data_size ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -bool RsGRouterSignedReceiptItem::serialise(void *data,uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, routing_id); - ok &= setRawUInt32(data, tlvsize, &offset, flags); - ok &= destination_key.serialise(data,tlvsize,offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, service_id); - ok &= data_hash.serialise(data,tlvsize,offset) ; - ok &= signature.SetTlv(data,tlvsize,&offset) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterReceiptItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -bool RsGRouterSignedReceiptItem::serialise_signed_data(void *data,uint32_t size) const -{ - bool ok = true; - - uint32_t offset=0; - uint32_t tlvsize = signed_data_size() ; - - if(tlvsize > size) - { - ok = false; - std::cerr << "RsGRouterReceiptItem::serialisedata() size error! Not enough size in supplied container." << std::endl; - } - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, routing_id); - ok &= setRawUInt32(data, tlvsize, &offset, flags); - ok &= destination_key.serialise(data,tlvsize,offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, service_id); - ok &= data_hash.serialise(data,tlvsize,offset) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterReceiptItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -/* serialise the data to the buffer */ -uint32_t RsGRouterMatrixCluesItem::serial_size() const -{ - uint32_t s = 8 ; // header - - s += destination_key.serial_size() ; // Key size - s += 4 ; // list::size() - s += (4+4+8) * clues.size() ; - - return s ; -} -uint32_t RsGRouterMatrixFriendListItem::serial_size() const -{ - uint32_t s = 8 ; // header - s += 4 ; // reverse_friend_indices.size() - s += RsPeerId::SIZE_IN_BYTES * reverse_friend_indices.size() ; // sha1 for published_key - - return s ; -} - -uint32_t RsGRouterMatrixTrackItem::serial_size() const -{ - uint32_t s = 8 ; // header - s += 8 ; // time_stamp - s += RsPeerId::SIZE_IN_BYTES; // provider_id - s += RsMessageId::SIZE_IN_BYTES; // message_id - - return s ; -} - -uint32_t RsGRouterRoutingInfoItem::serial_size() const -{ - uint32_t s = 8 ; // header - s += PeerId().serial_size() ; - - s += 4 ; // data status_flags - s += 4 ; // tunnel status_flags - s += 8 ; // received_time - s += 8 ; // last_sent_TS - - s += 8 ; // last_TR_TS - s += 4 ; // sending attempts - - s += sizeof(GRouterServiceId) ; // service_id - s += tunnel_hash.serial_size() ; - s += item_hash.serial_size() ; - - s += 4 ; // routing_flags - s += incoming_routes.TlvSize() ; // incoming_routes - - s += data_item->serial_size(); // data_item - - if(receipt_item != NULL) - s += receipt_item->serial_size(); // receipt_item - - return s ; -} - -bool RsGRouterMatrixFriendListItem::serialise(void *data,uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, reverse_friend_indices.size()); - - for(uint32_t i=0;ok && i::const_iterator it2(clues.begin());it2!=clues.end();++it2) - { - ok &= setRawUInt32(data, tlvsize, &offset, (*it2).friend_id) ; - ok &= setRawUFloat32(data, tlvsize, &offset, (*it2).weight) ; - ok &= setRawTimeT(data, tlvsize, &offset, (*it2).time_stamp) ; - } - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterMatrixCluesItem::serialisedata() size error! " << std::endl; - } - - return ok; -} - -bool RsGRouterMatrixTrackItem::serialise(void *data,uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= provider_id.serialise(data, tlvsize, offset) ; - ok &= message_id.serialise(data,tlvsize,offset) ; - ok &= setRawTimeT(data, tlvsize, &offset, time_stamp) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterMatrixTrackItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -bool FriendTrialRecord::deserialise(void *data,uint32_t& offset,uint32_t size) -{ - bool ok = true ; - ok &= friend_id.deserialise(data, size, offset) ; - ok &= getRawTimeT(data, size, &offset, time_stamp) ; - ok &= getRawUFloat32(data, size, &offset, probability) ; - ok &= getRawUInt32(data, size, &offset, &nb_friends) ; - return ok ; -} -bool FriendTrialRecord::serialise(void *data,uint32_t& offset,uint32_t size) const -{ - bool ok = true ; - ok &= friend_id.serialise(data, size, offset) ; - ok &= setRawTimeT(data, size, &offset, time_stamp) ; - ok &= setRawUFloat32(data, size, &offset, probability) ; - ok &= setRawUInt32(data, size, &offset, nb_friends) ; - return ok ; -} -bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= PeerId().serialise(data, tlvsize, offset) ; // we keep this. - ok &= setRawUInt32(data, tlvsize, &offset, data_status) ; - ok &= setRawUInt32(data, tlvsize, &offset, tunnel_status) ; - ok &= setRawTimeT(data, tlvsize, &offset, received_time_TS) ; - ok &= setRawTimeT(data, tlvsize, &offset, last_sent_TS) ; - ok &= setRawTimeT(data, tlvsize, &offset, last_tunnel_request_TS) ; - ok &= setRawUInt32(data, tlvsize, &offset, sending_attempts) ; - - ok &= setRawUInt32(data, tlvsize, &offset, client_id) ; - ok &= item_hash.serialise(data, tlvsize, offset) ; - ok &= tunnel_hash.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, routing_flags) ; - - ok &= incoming_routes.SetTlv(data,tlvsize,&offset) ; - - uint32_t ns = size - offset ; - ok &= data_item->serialise( &((uint8_t*)data)[offset], ns) ; - offset += data_item->serial_size() ; - - if(receipt_item != NULL) - { - uint32_t ns = size - offset ; - ok &= receipt_item->serialise( &((uint8_t*)data)[offset], ns) ; - offset += receipt_item->serial_size() ; - } - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGRouterRoutingInfoItem::serialisedata() size error! " << std::endl; - } - - return ok; -} - -// -----------------------------------------------------------------------------------// -// ------------------------------------- IO --------------------------------------- // -// -----------------------------------------------------------------------------------// -// - -std::ostream& RsGRouterSignedReceiptItem::print(std::ostream& o, uint16_t) -{ - o << "RsGRouterReceiptItem:" << std::endl ; - o << " direct origin: \""<< PeerId() << "\"" << std::endl ; - o << " Mid: " << std::hex << routing_id << std::dec << std::endl ; - o << " State: " << flags << std::endl ; - o << " Dest: " << destination_key << std::endl ; - o << " Sign: " << signature.keyId << std::endl ; - - return o ; -} -std::ostream& RsGRouterGenericDataItem::print(std::ostream& o, uint16_t) -{ - o << "RsGRouterGenericDataItem:" << std::endl ; - o << " Direct origin: \""<< PeerId() << "\"" << std::endl ; - o << " Routing ID: " << std::hex << routing_id << std::dec << "\"" << std::endl ; - o << " Key: " << destination_key.toStdString() << std::endl ; - o << " Data size: " << data_size << std::endl ; - o << " Data hash: " << RsDirUtil::sha1sum(data_bytes,data_size) << std::endl ; - o << " signature key: " << signature.keyId << std::endl; - o << " duplication fac:" << duplication_factor << std::endl; - o << " flags: " << flags << std::endl; - - return o ; -} - -std::ostream& RsGRouterRoutingInfoItem::print(std::ostream& o, uint16_t) -{ - o << "RsGRouterRoutingInfoItem:" << std::endl ; - o << " direct origin: "<< PeerId() << std::endl ; - o << " data status: "<< std::hex<< data_status << std::dec << std::endl ; - o << " tunnel status: "<< tunnel_status << std::endl ; - o << " recv time: "<< received_time_TS << std::endl ; - o << " Last sent: "<< last_sent_TS << std::endl ; - o << " Sending attempts:"<< sending_attempts << std::endl ; - o << " destination key: "<< data_item->destination_key << std::endl ; - o << " Client id: "<< client_id << std::endl ; - o << " item hash: "<< item_hash << std::endl ; - o << " tunnel hash: "<< tunnel_hash << std::endl ; - o << " Data size: "<< data_item->data_size << std::endl ; - o << " Signed receipt: "<< (void*)receipt_item << std::endl ; - - return o ; -} - -std::ostream& RsGRouterMatrixTrackItem::print(std::ostream& o, uint16_t) -{ - o << "RsGRouterMatrixTrackItem:" << std::endl ; - o << " provider_id: " << provider_id << std::endl; - o << " message_id: " << message_id << std::endl; - o << " time_stamp: " << time_stamp << std::endl; - - return o ; -} -std::ostream& RsGRouterMatrixCluesItem::print(std::ostream& o, uint16_t) -{ - o << "RsGRouterMatrixCluesItem:" << std::endl ; - o << " destination k: " << destination_key.toStdString() << std::endl; - o << " routing clues: " << clues.size() << std::endl; - - for(std::list::const_iterator it(clues.begin());it!=clues.end();++it) - o << " " << (*it).friend_id << " " << (*it).time_stamp << " " << (*it).weight << std::endl; - - return o ; -} -std::ostream& RsGRouterTransactionChunkItem::print(std::ostream& o, uint16_t) -{ - o << "RsGRouterTransactionChunkItem:" << std::endl ; - o << " total_size: " << total_size << std::endl; - o << " chunk_size: " << chunk_size << std::endl; - o << " chunk_start: " << chunk_start << std::endl; - - return o ; -} -std::ostream& RsGRouterTransactionAcknItem::print(std::ostream& o, uint16_t) -{ - o << "RsGRouterTransactionAcknItem:" << std::endl ; - o << " routing id: " << propagation_id << std::endl; - - return o ; -} -std::ostream& RsGRouterMatrixFriendListItem::print(std::ostream& o, uint16_t) -{ - o << "RsGRouterMatrixCluesItem:" << std::endl ; - o << " friends: " << reverse_friend_indices.size() << std::endl; - - return o ; -} -#endif diff --git a/libretroshare/src/grouter/p3grouter.cc b/libretroshare/src/grouter/p3grouter.cc index 998f7e636..d77903df8 100644 --- a/libretroshare/src/grouter/p3grouter.cc +++ b/libretroshare/src/grouter/p3grouter.cc @@ -2205,26 +2205,6 @@ Sha1CheckSum p3GRouter::makeTunnelHash(const RsGxsId& destination,const GRouterS return RsDirUtil::sha1sum(bytes,20) ; } -#ifdef TO_REMOVE -bool p3GRouter::locked_getGxsOwnIdAndClientIdFromHash(const TurtleFileHash& sum,RsGxsId& gxs_id,GRouterServiceId& client_id) -{ - assert( gxs_id.SIZE_IN_BYTES == 16) ; - assert(Sha1CheckSum::SIZE_IN_BYTES == 20) ; - - //gxs_id = RsGxsId(sum.toByteArray());// takes the first 16 bytes - //client_id = sum.toByteArray()[19] + (sum.toByteArray()[18] << 8) ; - - std::map::const_iterator it = _owned_key_ids.find(sum); - - if(it == _owned_key_ids.end()) - return false ; - - gxs_id = it->second.authentication_key ; - client_id = it->second.service_id ; - - return true ; -} -#endif bool p3GRouter::loadList(std::list& items) { { diff --git a/libretroshare/src/gxstunnel/rsgxstunnelitems.cc b/libretroshare/src/gxstunnel/rsgxstunnelitems.cc index bb56e93cc..8e488c190 100644 --- a/libretroshare/src/gxstunnel/rsgxstunnelitems.cc +++ b/libretroshare/src/gxstunnel/rsgxstunnelitems.cc @@ -52,152 +52,11 @@ RsItem *RsGxsTunnelSerialiser::create_item(uint16_t service,uint8_t item_subtype } } -#ifdef TO_REMOVE -std::ostream& RsGxsTunnelDHPublicKeyItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsTunnelDHPublicKeyItem", 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, "RsGxsTunnelMsgItem", indent); - return out; -} - -std::ostream& RsGxsTunnelDataItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsTunnelDataItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << " message id : " << std::hex << unique_item_counter << std::dec << std::endl ; - out << " service id : " << std::hex << service_id << std::dec << std::endl ; - out << " flags : " << std::hex << flags << std::dec << std::endl ; - out << " size : " << data_size << std::endl ; - out << " data : " << RsUtil::BinToHex(data,std::min(50u,data_size)) << ((data_size>50u)?"...":"") << std::endl ; - - printRsItemEnd(out, "RsGxsTunnelDataItem", indent); - return out; -} -std::ostream& RsGxsTunnelDataAckItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsTunnelDataItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << " message id : " << std::hex << unique_item_counter << std::dec << std::endl ; - - printRsItemEnd(out, "RsGxsTunnelDataAckItem", indent); - return out; -} -std::ostream& RsGxsTunnelStatusItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsTunnelDataItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << " flags : " << std::hex << status << std::dec << std::endl ; - - printRsItemEnd(out, "RsGxsTunnelStatusItem", indent); - return out; -} - -/*************************************************************************/ -#endif - RsGxsTunnelDHPublicKeyItem::~RsGxsTunnelDHPublicKeyItem() { BN_free(public_key) ; } -#ifdef TO_REMOVE -/*************************************************************************/ - -RsItem *RsGxsTunnelSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - -#ifdef GXS_TUNNEL_ITEM_DEBUG - std::cerr << "deserializing packet..."<< std::endl ; -#endif - // look what we have... - if (*pktsize < rssize) /* check size */ - { - std::cerr << "GxsTunnel deserialisation: not enough size: pktsize=" << *pktsize << ", rssize=" << rssize << std::endl ; - return NULL; /* not enough data */ - } - - /* set the packet length */ - *pktsize = rssize; - - /* ready to load */ - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_GXS_TUNNEL != getRsItemService(rstype))) - { -#ifdef GXS_TUNNEL_ITEM_DEBUG - std::cerr << "GxsTunnel deserialisation: wrong type !" << std::endl ; -#endif - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_GXS_TUNNEL_DH_PUBLIC_KEY: return deserialise_RsGxsTunnelDHPublicKeyItem(data,*pktsize) ; - case RS_PKT_SUBTYPE_GXS_TUNNEL_DATA: return deserialise_RsGxsTunnelDataItem (data,*pktsize) ; - case RS_PKT_SUBTYPE_GXS_TUNNEL_DATA_ACK: return deserialise_RsGxsTunnelDataAckItem (data,*pktsize) ; - case RS_PKT_SUBTYPE_GXS_TUNNEL_STATUS: return deserialise_RsGxsTunnelStatusItem (data,*pktsize) ; - default: - std::cerr << "Unknown packet type in chat!" << std::endl ; - return NULL ; - } -} - -/*************************************************************************/ - -uint32_t RsGxsTunnelDHPublicKeyItem::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 ; -} - -uint32_t RsGxsTunnelDataItem::serial_size() -{ - uint32_t s = 8 ; // header - s += 8 ; // counter - s += 4 ; // flags - s += 4 ; // service id - s += 4 ; // data_size - s += data_size; // data - - return s ; -} - -uint32_t RsGxsTunnelDataAckItem::serial_size() -{ - uint32_t s = 8 ; // header - s += 8 ; // counter - - return s ; -} - -uint32_t RsGxsTunnelStatusItem::serial_size() -{ - uint32_t s = 8 ; // header - s += 4 ; // flags - - return s ; -} -/*************************************************************************/ -#endif - void RsGxsTunnelDHPublicKeyItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,public_key,"public_key") ; @@ -243,88 +102,11 @@ template<> void RsTypeSerializer::print_data(const std::string& name,BIGNUM std::cerr << "[BIGNUM] : " << name << std::endl; } -#ifdef TO_REMOVE -bool RsGxsTunnelDHPublicKeyItem::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 << "RsGxsTunnelDHPublicKeyItem::serialiseItem() Size Error! offset=" << offset << ", tlvsize=" << tlvsize << std::endl; - } - return ok ; -} -#endif - void RsGxsTunnelStatusItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,status,"status") ; } -#ifdef TO_REMOVE -bool RsGxsTunnelStatusItem::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); - -#ifdef GXS_TUNNEL_ITEM_DEBUG - std::cerr << "RsGxsTunnelSerialiser serialising chat status item." << std::endl; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, status); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Size Error! " << std::endl; - } -#ifdef GXS_TUNNEL_ITEM_DEBUG - std::cerr << "computed size: " << 256*((unsigned char*)data)[6]+((unsigned char*)data)[7] << std::endl ; -#endif - - return ok; -} -#endif - void RsGxsTunnelDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,unique_item_counter,"unique_item_counter") ; @@ -339,247 +121,6 @@ void RsGxsTunnelDataAckItem::serial_process(RsGenericSerializer::SerializeJob j, RsTypeSerializer::serial_process(j,ctx,unique_item_counter,"unique_item_counter") ; } -#ifdef TO_REMOVE -bool RsGxsTunnelDataItem::serialise(void *dt, 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(dt, tlvsize, PacketId(), tlvsize); - -#ifdef GXS_TUNNEL_ITEM_DEBUG - std::cerr << "RsGxsTunnelSerialiser serialising chat status item." << std::endl; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt64(dt, tlvsize, &offset, unique_item_counter); - ok &= setRawUInt32(dt, tlvsize, &offset, flags); - ok &= setRawUInt32(dt, tlvsize, &offset, service_id); - ok &= setRawUInt32(dt, tlvsize, &offset, data_size); - - if(offset + data_size <= tlvsize) - { - memcpy(&((uint8_t*)dt)[offset],data,data_size) ; - offset += data_size ; - } - else - ok = false ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Size Error! " << std::endl; - } - - return ok; -} -bool RsGxsTunnelDataAckItem::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); - -#ifdef GXS_TUNNEL_ITEM_DEBUG - std::cerr << "RsGxsTunnelSerialiser serialising chat status item." << std::endl; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt64(data, tlvsize, &offset, unique_item_counter); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGxsTunnelSerialiser::serialiseItem() Size Error! " << std::endl; - } - - return ok; -} - -/*************************************************************************/ - -RsGxsTunnelDHPublicKeyItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelDHPublicKeyItem(void *data,uint32_t /*size*/) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGxsTunnelDHPublicKeyItem *item = new RsGxsTunnelDHPublicKeyItem() ; - - uint32_t s=0 ; - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &s); - - if(s > rssize || rssize - s < offset) - { - std::cerr << "RsGxsTunnelDHPublicKeyItem::() Size error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - - item->public_key = BN_bin2bn(&((unsigned char *)data)[offset],s,NULL) ; - offset += s ; - - ok &= item->signature.GetTlv(data, rssize, &offset) ; - ok &= item->gxs_key.GetTlv(data, rssize, &offset) ; - - if (offset != rssize) - { - std::cerr << "RsGxsTunnelDHPublicKeyItem::() Size error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - if (!ok) - { - std::cerr << "RsGxsTunnelDHPublicKeyItem::() Unknown error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - - return item ; -} - -RsGxsTunnelDataItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelDataItem(void *dat,uint32_t size) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(dat); - bool ok = true ; - - if(rssize > size) - { - std::cerr << "RsGxsTunnelDataItem::() Size error while deserializing." << std::endl ; - return NULL ; - } - - RsGxsTunnelDataItem *item = new RsGxsTunnelDataItem(); - - /* get mandatory parts first */ - - ok &= getRawUInt64(dat, rssize, &offset, &item->unique_item_counter); - ok &= getRawUInt32(dat, rssize, &offset, &item->flags); - ok &= getRawUInt32(dat, rssize, &offset, &item->service_id); - ok &= getRawUInt32(dat, rssize, &offset, &item->data_size); - - if(item->data_size > rssize || rssize < offset + item->data_size) - { - std::cerr << "RsGxsTunnelDataItem::() Size error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - item->data = (unsigned char*)rs_malloc(item->data_size) ; - - if(item->data == NULL) - { - delete item ; - return NULL ; - } - - memcpy(item->data,&((uint8_t*)dat)[offset],item->data_size) ; - offset += item->data_size ; - - - if (offset != rssize) - { - std::cerr << "RsGxsTunnelDHPublicKeyItem::() Size error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - if (!ok) - { - std::cerr << "RsGxsTunnelDHPublicKeyItem::() Unknown error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - - return item ; -} - -RsGxsTunnelDataAckItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelDataAckItem(void *dat,uint32_t /* size */) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(dat); - bool ok = true ; - - RsGxsTunnelDataAckItem *item = new RsGxsTunnelDataAckItem(); - - /* get mandatory parts first */ - - ok &= getRawUInt64(dat, rssize, &offset, &item->unique_item_counter); - - if (offset != rssize) - { - std::cerr << "RsGxsTunnelDHPublicKeyItem::() Size error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - if (!ok) - { - std::cerr << "RsGxsTunnelDHPublicKeyItem::() Unknown error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - - return item ; -} - -RsGxsTunnelStatusItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelStatusItem(void *dat, uint32_t size) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(dat); - bool ok = true ; - - if(rssize > size) - { - std::cerr << "RsGxsTunnelStatusItem::() Size error while deserializing." << std::endl ; - return NULL ; - } - - RsGxsTunnelStatusItem *item = new RsGxsTunnelStatusItem(); - - /* get mandatory parts first */ - - ok &= getRawUInt32(dat, rssize, &offset, &item->status); - - if (offset != rssize) - { - std::cerr << "RsGxsTunnelStatusItem::() Size error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - if (!ok) - { - std::cerr << "RsGxsTunnelStatusItem::() Unknown error while deserializing." << std::endl ; - delete item ; - return NULL ; - } - - return item ; -} -#endif diff --git a/libretroshare/src/pqi/p3peermgr.cc b/libretroshare/src/pqi/p3peermgr.cc index 5ae948d86..cad91f30b 100644 --- a/libretroshare/src/pqi/p3peermgr.cc +++ b/libretroshare/src/pqi/p3peermgr.cc @@ -2294,44 +2294,6 @@ bool p3PeerMgrIMPL::loadList(std::list& load) continue; } -#ifdef TO_REMOVE - RsPeerGroupItem_deprecated *gitem = dynamic_cast(*it) ; - - if (gitem) - { - RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ - -#ifdef PEER_DEBUG - std::cerr << "p3PeerMgrIMPL::loadList() Peer group item:" << std::endl; - gitem->print(std::cerr, 10); - std::cerr << std::endl; -#endif - RsGroupInfo ginfo ; - ginfo.flag = gitem->flag ; - ginfo.name = gitem->name ; - ginfo.peerIds = gitem->pgpList.ids ; - - do { ginfo.id = RsNodeGroupId::random(); } while(groupList.find(ginfo.id) != groupList.end()) ; - - // Ensure backward compatibility when loading the group in old format. The id must matchthe standard default id. - - if(gitem->id == std::string(RS_GROUP_DEFAULT_NAME_FRIENDS )) ginfo.id = RS_GROUP_ID_FRIENDS ; - if(gitem->id == std::string(RS_GROUP_DEFAULT_NAME_COWORKERS)) ginfo.id = RS_GROUP_ID_COWORKERS ; - if(gitem->id == std::string(RS_GROUP_DEFAULT_NAME_FAMILY )) ginfo.id = RS_GROUP_ID_FAMILY ; - if(gitem->id == std::string(RS_GROUP_DEFAULT_NAME_FAVORITES)) ginfo.id = RS_GROUP_ID_FAVORITES ; - if(gitem->id == std::string(RS_GROUP_DEFAULT_NAME_OTHERS )) ginfo.id = RS_GROUP_ID_OTHERS ; - - if(!ginfo.id.isNull()) - { - groupList[ginfo.id] = ginfo ; - std::cerr << "(II) Creating new group for old format local group \"" << gitem->name << "\". Id=" << ginfo.id << std::endl; - } - else - std::cerr << "(EE) no group corresponding to old format group with ID=\"" << gitem->id << "\"" << std::endl; - - continue; - } -#endif RsNodeGroupItem *gitem2 = dynamic_cast(*it) ; diff --git a/libretroshare/src/rsitems/rsbwctrlitems.cc b/libretroshare/src/rsitems/rsbwctrlitems.cc index 45c23d2c8..bfa172b45 100644 --- a/libretroshare/src/rsitems/rsbwctrlitems.cc +++ b/libretroshare/src/rsitems/rsbwctrlitems.cc @@ -57,143 +57,5 @@ void RsBwCtrlAllowedItem::serial_process(RsGenericSerializer::SerializeJob j,RsG RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_UINT32_BW,allowedBw,"allowedBw") ; } -#ifdef TO_REMOVE -/* serialise the data to the buffer */ -bool RsBwCtrlSerialiser::serialiseAllowed(RsBwCtrlAllowedItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeAllowed(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsBwCtrlSerialiser::serialiseRoute() Header: " << ok << std::endl; - std::cerr << "RsBwCtrlSerialiser::serialiseRoute() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= SetTlvUInt32(data, tlvsize, &offset, TLV_TYPE_UINT32_BW, item->allowedBw); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsBwCtrlSerialiser::serialiseRoute() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsBwCtrlAllowedItem *RsBwCtrlSerialiser::deserialiseAllowed(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t tlvsize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_BWCTRL != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_BWCTRL_ALLOWED_ITEM != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < tlvsize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = tlvsize; - - bool ok = true; - - /* ready to load */ - RsBwCtrlAllowedItem *item = new RsBwCtrlAllowedItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= GetTlvUInt32(data, tlvsize, &offset, TLV_TYPE_UINT32_BW, &(item->allowedBw)); - - - if (offset != tlvsize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ - -uint32_t RsBwCtrlSerialiser::size(RsItem *i) -{ - RsBwCtrlAllowedItem *dri; - - if (NULL != (dri = dynamic_cast(i))) - { - return sizeAllowed(dri); - } - return 0; -} - -bool RsBwCtrlSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsBwCtrlAllowedItem *dri; - - if (NULL != (dri = dynamic_cast(i))) - { - return serialiseAllowed(dri, data, pktsize); - } - return false; -} - -RsItem *RsBwCtrlSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_BWCTRL != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_BWCTRL_ALLOWED_ITEM: - return deserialiseAllowed(data, pktsize); - break; - default: - return NULL; - break; - } -} - -/*************************************************************************/ -#endif - diff --git a/libretroshare/src/rsitems/rsconfigitems.h b/libretroshare/src/rsitems/rsconfigitems.h index d4ea41898..4e31b2d43 100644 --- a/libretroshare/src/rsitems/rsconfigitems.h +++ b/libretroshare/src/rsitems/rsconfigitems.h @@ -140,30 +140,6 @@ class RsPeerBandwidthLimitsItem : public RsItem std::map peers ; }; -#ifdef TO_REMOVE -class RsPeerGroupItem_deprecated : public RsItem -{ -public: - RsPeerGroupItem_deprecated(); - virtual ~RsPeerGroupItem_deprecated(); - - virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - /* set data from RsGroupInfo to RsPeerGroupItem */ - void set(RsGroupInfo &groupInfo); - /* get data from RsGroupInfo to RsPeerGroupItem */ - void get(RsGroupInfo &groupInfo); - - /* Mandatory */ - std::string id; - std::string name; - uint32_t flag; - - RsTlvPgpIdSet pgpList; -}; -#endif - class RsNodeGroupItem: public RsItem { public: @@ -216,51 +192,6 @@ class RsPeerConfigSerialiser: public RsConfigSerializer /**************************************************************************/ -#ifdef TO_REMOVE -class RsCacheConfig: public RsItem -{ - public: - RsCacheConfig() - :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_CACHE_CONFIG, - RS_PKT_SUBTYPE_DEFAULT) - { return; } -virtual ~RsCacheConfig(); -virtual void clear(); -std::ostream &print(std::ostream &out, uint16_t indent = 0); - - RsPeerId pid; /* Mandatory */ - uint16_t cachetypeid; /* Mandatory */ - uint16_t cachesubid; /* Mandatory */ - - std::string path; /* Mandatory */ - std::string name; /* Mandatory */ - RsFileHash hash; /* Mandatory */ - uint64_t size; /* Mandatory */ - - uint32_t recvd; /* Mandatory */ -}; - - -class RsCacheConfigSerialiser: public RsSerialType -{ - public: - RsCacheConfigSerialiser() - :RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_CACHE_CONFIG) - { return; } - -virtual ~RsCacheConfigSerialiser(); - -virtual uint32_t size(RsItem *); -virtual bool serialise (RsItem *item, void *data, uint32_t *size); -virtual RsItem * deserialise(void *data, uint32_t *size); - -}; -#endif - -/**************************************************************************/ - class RsFileTransfer: public RsItem { public: @@ -306,26 +237,6 @@ class RsFileTransfer: public RsItem const uint32_t RS_FILE_CONFIG_CLEANUP_DELETE = 0x0001; -#ifdef TO_REMOVE -/* Used by ft / extralist / configdirs / anyone who wants a basic file */ -class RsFileConfigItem_deprecated: public RsItem -{ -public: - RsFileConfigItem_deprecated() - :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_FILE_CONFIG, - RS_PKT_SUBTYPE_FILE_ITEM_deprecated) - {} - virtual ~RsFileConfigItem_deprecated() {} - virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - RsTlvFileItem file; - uint32_t flags; - std::list parent_groups ; -}; -#endif - class RsFileConfigItem: public RsItem { public: diff --git a/libretroshare/src/rsitems/rsgxscommentitems.cc b/libretroshare/src/rsitems/rsgxscommentitems.cc index 407f64204..8c175a1bd 100644 --- a/libretroshare/src/rsitems/rsgxscommentitems.cc +++ b/libretroshare/src/rsitems/rsgxscommentitems.cc @@ -46,403 +46,14 @@ RsItem *RsGxsCommentSerialiser::create_item(uint16_t service_id,uint8_t item_sub } } -#ifdef TO_REMOVE - -uint32_t RsGxsCommentSerialiser::size(RsItem *item) -{ -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::size()" << std::endl; -#endif - - RsGxsCommentItem* com_item = NULL; - RsGxsVoteItem* vote_item = NULL; - - if((com_item = dynamic_cast(item)) != NULL) - { - return sizeGxsCommentItem(com_item); - } - else if((vote_item = dynamic_cast(item)) != NULL) - { - return sizeGxsVoteItem(vote_item); - } - std::cerr << "RsGxsCommentSerialiser::size() ERROR invalid item" << std::endl; - return 0; -} - -bool RsGxsCommentSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::serialise()" << std::endl; -#endif - - RsGxsCommentItem* com_item = NULL; - RsGxsVoteItem* vote_item = NULL; - - if((com_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsCommentItem(com_item, data, size); - } - else if((vote_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsVoteItem(vote_item, data, size); - } - std::cerr << "RsGxsCommentSerialiser::serialise() ERROR invalid item" << std::endl; - return false; -} - -RsItem* RsGxsCommentSerialiser::deserialise(void* data, uint32_t* size) -{ - -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (getRsItemService(PacketId()) != getRsItemService(rstype))) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialise() ERROR Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_GXSCOMMENT_COMMENT_ITEM: - return deserialiseGxsCommentItem(data, size); - break; - case RS_PKT_SUBTYPE_GXSCOMMENT_VOTE_ITEM: - return deserialiseGxsVoteItem(data, size); - break; - default: -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialise(): unknown subtype"; - std::cerr << std::endl; -#endif - break; - } - return NULL; -} - - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsCommentItem::clear() -{ - mMsg.mComment.clear(); -} - -std::ostream& RsGxsCommentItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsCommentItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Comment: " << mMsg.mComment << std::endl; - - printRsItemEnd(out ,"RsGxsCommentItem", indent); - return out; -} - - -uint32_t RsGxsCommentSerialiser::sizeGxsCommentItem(RsGxsCommentItem *item) -{ - - const RsGxsComment& msg = item->mMsg; - uint32_t s = 8; // header - - s += GetTlvStringSize(msg.mComment); // mMsg. - -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::sizeGxsCommentItem() is: " << s << std::endl; - msg.print(std::cerr); -#endif - - return s; -} -#endif - void RsGxsCommentItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,1,mMsg.mComment,"mMsg.mComment") ; } -#ifdef TO_REMOVE -bool RsGxsCommentSerialiser::serialiseGxsCommentItem(RsGxsCommentItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::serialiseGxsCommentItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsCommentItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::serialiseGxsCommentItem() Failed size too small" << std::endl; -#endif - - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsCommentItem */ - ok &= SetTlvString(data, tlvsize, &offset, 1, item->mMsg.mComment); - - if(offset != tlvsize) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::serialiseGxsCommentItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSCOMMENT_DEBUG - if (!ok) - { - std::cerr << "RsGxsCommentSerialiser::serialiseGxsCommentItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsCommentItem* RsGxsCommentSerialiser::deserialiseGxsCommentItem(void *data, uint32_t *size) -{ - -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsCommentItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (getRsItemService(PacketId()) != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSCOMMENT_COMMENT_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsCommentItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsCommentItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsCommentItem* item = new RsGxsCommentItem(getRsItemService(PacketId())); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, 1, item->mMsg.mComment); - - if (offset != rssize) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsCommentItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsCommentItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsVoteItem::clear() -{ - mMsg.mVoteType = 0; -} - -std::ostream& RsGxsVoteItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsVoteItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "VoteType: " << mMsg.mVoteType << std::endl; - - printRsItemEnd(out ,"RsGxsVoteItem", indent); - return out; -} - - -uint32_t RsGxsCommentSerialiser::sizeGxsVoteItem(RsGxsVoteItem */*item*/) -{ - uint32_t s = 8; // header - - s += 4; // vote flags. - - return s; -} -#endif - void RsGxsVoteItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,mMsg.mVoteType,"mMsg.mVoteType") ; } -#ifdef TO_REMOVE -bool RsGxsCommentSerialiser::serialiseGxsVoteItem(RsGxsVoteItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::serialiseGxsVoteItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsVoteItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::serialiseGxsVoteItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsVoteItem */ - ok &= setRawUInt32(data, tlvsize, &offset, item->mMsg.mVoteType); - - if(offset != tlvsize) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::serialiseGxsVoteItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSCOMMENT_DEBUG - if (!ok) - { - std::cerr << "RsGxsCommentSerialiser::serialiseGxsVoteItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsVoteItem* RsGxsCommentSerialiser::deserialiseGxsVoteItem(void *data, uint32_t *size) -{ - -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsVoteItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (getRsItemService(PacketId()) != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSCOMMENT_VOTE_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsVoteItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsVoteItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsVoteItem* item = new RsGxsVoteItem(getRsItemService(PacketId())); - /* skip the header */ - offset += 8; - - ok &= getRawUInt32(data, rssize, &offset, &(item->mMsg.mVoteType)); - - if (offset != rssize) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsVoteItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSCOMMENT_DEBUG - std::cerr << "RsGxsCommentSerialiser::deserialiseGxsVoteItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -#endif diff --git a/libretroshare/src/rsitems/rsgxsiditems.cc b/libretroshare/src/rsitems/rsgxsiditems.cc index 5bf55b549..1a4eac4e8 100644 --- a/libretroshare/src/rsitems/rsgxsiditems.cc +++ b/libretroshare/src/rsitems/rsgxsiditems.cc @@ -60,172 +60,12 @@ void RsGxsIdGroupItem::clear() mRecognTags.clear(); mImage.TlvClear(); } -#ifdef TO_REMOVE -RsItem* RsGxsIdSerialiser::deserialise(void* data, uint32_t* size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_GXS_TYPE_GXSID != getRsItemService(rstype))) - return NULL; /* wrong type */ - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_GXSID_GROUP_ITEM: return deserialise_GxsIdGroupItem(data, size); - case RS_PKT_SUBTYPE_GXSID_LOCAL_INFO_ITEM: return deserialise_GxsIdLocalInfoItem(data, size); -#if 0 - case RS_PKT_SUBTYPE_GXSID_OPINION_ITEM: return deserialise_GxsIdOpinionItem(data, size); - case RS_PKT_SUBTYPE_GXSID_COMMENT_ITEM: return deserialise_GxsIdCommentItem(data, size); -#endif - default: -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialise(): unknown subtype"; - std::cerr << std::endl; -#endif - break; - } - return NULL; -} - -bool RsGxsIdItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) -{ - tlvsize = serial_size() ; - offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsItem::serialise_header(): ERROR. Not enough size!" << std::endl; - return false ; - } - offset += 8; - - return true ; -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - - - -uint32_t RsGxsIdLocalInfoItem::serial_size() -{ - uint32_t s = 8 ; // header - s += 4 ; // number of items - s += mTimeStamps.size() * (RsGxsId::SIZE_IN_BYTES + 8) ; - s += 4 ; // number of contacts - s += mContacts.size() * RsGxsId::SIZE_IN_BYTES ; - - return s; -} - -std::ostream& RsGxsIdLocalInfoItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsIdLocalInfoItem", indent); - - // convert from binary to hex. - for(std::map::const_iterator it(mTimeStamps.begin());it!=mTimeStamps.end();++it) - out << it->first << " : " << it->second << std::endl; - - printRsItemEnd(out ,"RsGxsIdLocalInfoItem", indent); - return out; -} -std::ostream& RsGxsIdGroupItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsIdGroupItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "MetaData: " << meta << std::endl; - printIndent(out, int_Indent); - out << "PgpIdHash: " << mPgpIdHash << std::endl; - printIndent(out, int_Indent); - - std::string signhex; - // convert from binary to hex. - for(unsigned int i = 0; i < mPgpIdSign.length(); i++) - { - rs_sprintf_append(signhex, "%02x", (uint32_t) ((uint8_t) mPgpIdSign[i])); - } - out << "PgpIdSign: " << signhex << std::endl; - printIndent(out, int_Indent); - out << "RecognTags:" << std::endl; - - RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, mRecognTags); - set.print(out, int_Indent + 2); - - printRsItemEnd(out ,"RsGxsIdGroupItem", indent); - return out; -} - - -uint32_t RsGxsIdGroupItem::serial_size() -{ - uint32_t s = 8; // header - - s += Sha1CheckSum::SIZE_IN_BYTES; - s += GetTlvStringSize(mPgpIdSign); - - RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, mRecognTags); - s += set.TlvSize(); - s += mImage.TlvSize() ; - - return s; -} -#endif - void RsGxsIdLocalInfoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,mTimeStamps,"mTimeStamps") ; RsTypeSerializer::serial_process(j,ctx,mContacts,"mContacts") ; } -#ifdef TO_REMOVE -bool RsGxsIdLocalInfoItem::serialise(void *data, uint32_t& size) -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= setRawUInt32(data, tlvsize, &offset, mTimeStamps.size()) ; - - for(std::map::const_iterator it = mTimeStamps.begin();it!=mTimeStamps.end();++it) - { - ok &= it->first.serialise(data,tlvsize,offset) ; - ok &= setRawTimeT(data,tlvsize,&offset,it->second) ; - } - ok &= setRawUInt32(data, tlvsize, &offset, mContacts.size()) ; - - for(std::set::const_iterator it(mContacts.begin());it!=mContacts.end();++it) - ok &= (*it).serialise(data,tlvsize,offset) ; - - if(offset != tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::serialiseGxsIdGroupItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSID_DEBUG - if (!ok) - { - std::cerr << "RsGxsIdSerialiser::serialiseGxsIdgroupItem() NOK" << std::endl; - } -#endif - - return ok; -} -#endif - void RsGxsIdGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,mPgpIdHash,"mPgpIdHash") ; @@ -243,43 +83,6 @@ void RsGxsIdGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGene RsTypeSerializer::serial_process(j,ctx,mImage,"mImage") ; } -#ifdef TO_REMOVE -bool RsGxsIdGroupItem::serialise(void *data, uint32_t& size) -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* GxsIdGroupItem */ - ok &= mPgpIdHash.serialise(data, tlvsize, offset); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_SIGN, mPgpIdSign); - - RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, mRecognTags); - ok &= set.SetTlv(data, tlvsize, &offset); - - ok &= mImage.SetTlv(data,tlvsize,&offset) ; - - if(offset != tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::serialiseGxsIdGroupItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSID_DEBUG - if (!ok) - { - std::cerr << "RsGxsIdSerialiser::serialiseGxsIdgroupItem() NOK" << std::endl; - } -#endif - - return ok; -} -#endif - bool RsGxsIdGroupItem::fromGxsIdGroup(RsGxsIdGroup &group, bool moveImage) { clear(); @@ -320,422 +123,3 @@ bool RsGxsIdGroupItem::toGxsIdGroup(RsGxsIdGroup &group, bool moveImage) return true ; } -#ifdef TO_REMOVE -RsGxsIdGroupItem* RsGxsIdSerialiser::deserialise_GxsIdGroupItem(void *data, uint32_t *size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_GXSID != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSID_GROUP_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsIdGroupItem* item = new RsGxsIdGroupItem(); - /* skip the header */ - offset += 8; - - ok &= item->mPgpIdHash.deserialise(data, rssize, offset); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_SIGN, item->mPgpIdSign); - - RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->mRecognTags); - ok &= set.GetTlv(data, rssize, &offset); - - // image is optional,so that we can continue reading old items. - if(offset < rssize) - ok &= item->mImage.GetTlv(data,rssize,&offset) ; - - if (offset != rssize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} -RsGxsIdLocalInfoItem *RsGxsIdSerialiser::deserialise_GxsIdLocalInfoItem(void *data, uint32_t *size) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_GXSID != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSID_LOCAL_INFO_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsIdLocalInfoItem* item = new RsGxsIdLocalInfoItem(); - /* skip the header */ - offset += 8; - - uint32_t n=0 ; - ok &= getRawUInt32(data, rssize, &offset, &n) ; - - for(uint32_t i=0;ok && imTimeStamps[gxsid] = TS ; - } - - if (offset < rssize) // backward compatibility, making that section optional. - { - ok &= getRawUInt32(data, rssize, &offset, &n) ; - RsGxsId gxsid ; - - for(uint32_t i=0;ok && imContacts.insert(gxsid) ; - } - } - - if (offset != rssize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -#endif - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -#if 0 - -void RsGxsIdOpinionItem::clear() -{ - opinion.mOpinion = 0; - opinion.mReputation = 0; - opinion.mComment = ""; -} - -std::ostream& RsGxsIdOpinionItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsIdOpinionItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Opinion: " << opinion.mOpinion << std::endl; - printIndent(out, int_Indent); - out << "Reputation: " << opinion.mReputation << std::endl; - printIndent(out, int_Indent); - out << "Comment: " << opinion.mComment << std::endl; - - printRsItemEnd(out ,"RsGxsIdOpinionItem", indent); - return out; -} - - -uint32_t RsGxsIdOpinionItem::serial_size() -{ - - const RsGxsIdOpinion& opinion = item->opinion; - uint32_t s = 8; // header - - s += 4; // mOpinion. - s += 4; // mReputation. - s += GetTlvStringSize(opinion.mComment); - - return s; -} - -bool RsGxsIdOpinionItem::serialise(void *data, uint32_t *size) -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* GxsIdOpinionItem */ - ok &= setRawUInt32(data, tlvsize, &offset, item->opinion.mOpinion); - ok &= setRawUInt32(data, tlvsize, &offset, item->opinion.mReputation); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_COMMENT, item->opinion.mComment); - - if(offset != tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::serialiseGxsIdOpinionItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSID_DEBUG - if (!ok) - { - std::cerr << "RsGxsIdSerialiser::serialiseGxsIdgroupItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsIdOpinionItem* RsGxsIdSerialiser::deserialise_GxsIdOpinionItem(void *data, uint32_t *size) -{ - - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_GXSID != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSID_OPINION_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdOpinionItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdOpinionItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsIdOpinionItem* item = new RsGxsIdOpinionItem(); - /* skip the header */ - offset += 8; - - ok &= getRawUInt32(data, rssize, &offset, &(item->opinion.mOpinion)); - ok &= getRawUInt32(data, rssize, &offset, &(item->opinion.mReputation)); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_COMMENT, item->opinion.mComment); - - if (offset != rssize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdOpinionItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdOpinionItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsIdCommentItem::clear() -{ - comment.mComment.clear(); -} - -std::ostream& RsGxsIdCommentItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsIdCommentItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Comment: " << comment.mComment << std::endl; - - printRsItemEnd(out ,"RsGxsIdCommentItem", indent); - return out; -} - - -uint32_t RsGxsIdCommentItem::serial_size() -{ - - const RsGxsIdComment& comment = item->comment; - uint32_t s = 8; // header - - s += GetTlvStringSize(comment.mComment); - - return s; -} - -bool RsGxsIdCommentItem::serialise(void *data, uint32_t *size) -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* GxsIdCommentItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_COMMENT, item->comment.mComment); - - if(offset != tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::serialiseGxsIdCommentItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSID_DEBUG - if (!ok) - { - std::cerr << "RsGxsIdSerialiser::serialiseGxsIdgroupItem() NOK" << std::endl; - } -#endif - - return ok; -} - -RsGxsIdCommentItem* RsGxsIdSerialiser::deserialise_GxsIdCommentItem(void *data, uint32_t *size) -{ - - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_GXSID != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_GXSID_COMMENT_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdCommentItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdCommentItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsIdCommentItem* item = new RsGxsIdCommentItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_COMMENT, item->comment.mComment); - - if (offset != rssize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdCommentItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdCommentItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -#endif diff --git a/libretroshare/src/rsitems/rsgxsrecognitems.cc b/libretroshare/src/rsitems/rsgxsrecognitems.cc index 81b8d866b..bb6a40ca8 100644 --- a/libretroshare/src/rsitems/rsgxsrecognitems.cc +++ b/libretroshare/src/rsitems/rsgxsrecognitems.cc @@ -63,65 +63,6 @@ void RsGxsRecognReqItem::clear() sign.TlvClear(); } -#ifdef TO_REMOVE -RsGxsRecognReqItem::~RsGxsRecognReqItem() -{ - return; -} - - -std::ostream &RsGxsRecognReqItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsRecognReqItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "issued_at: " << issued_at << std::endl; - - printIndent(out, int_Indent); - out << "period: " << period << std::endl; - - printIndent(out, int_Indent); - out << "tag_class: " << tag_class << std::endl; - - printIndent(out, int_Indent); - out << "tag_type: " << tag_type << std::endl; - - printIndent(out, int_Indent); - out << "identity: " << identity << std::endl; - - printIndent(out, int_Indent); - out << "nickname: " << nickname << std::endl; - - printIndent(out, int_Indent); - out << "comment: " << comment << std::endl; - - printIndent(out, int_Indent); - out << "signature: " << std::endl; - sign.print(out, int_Indent + 2); - - printRsItemEnd(out, "RsGxsRecognReqItem", indent); - return out; -} - - -uint32_t RsGxsRecognSerialiser::sizeReq(RsGxsRecognReqItem *item) -{ - uint32_t s = 8; /* header */ - s += 4; // issued_at; - s += 4; // period; - s += 2; // tag_class; - s += 2; // tag_type; - s += item->identity.serial_size(); - s += GetTlvStringSize(item->nickname); - s += GetTlvStringSize(item->comment); - s += item->sign.TlvSize(); - - return s; -} - -#endif - void RsGxsRecognReqItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,issued_at ,"issued_at") ; @@ -134,122 +75,6 @@ void RsGxsRecognReqItem::serial_process(RsGenericSerializer::SerializeJob j,RsGe RsTypeSerializer::serial_process(j,ctx,sign ,"sign") ; } -#ifdef TO_REMOVE -/* serialise the data to the buffer */ -bool RsGxsRecognSerialiser::serialiseReq(RsGxsRecognReqItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeReq(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsRecognSerialiser::serialiseReq() Header: " << ok << std::endl; - std::cerr << "RsGxsRecognSerialiser::serialiseReq() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, item->issued_at); - ok &= setRawUInt32(data, tlvsize, &offset, item->period); - ok &= setRawUInt16(data, tlvsize, &offset, item->tag_class); - ok &= setRawUInt16(data, tlvsize, &offset, item->tag_type); - - - ok &= item->identity.serialise(data, tlvsize, offset); - ok &= SetTlvString(data, tlvsize, &offset, 1, item->nickname); - ok &= SetTlvString(data, tlvsize, &offset, 1, item->comment); - - ok &= item->sign.SetTlv(data, tlvsize, &offset); - - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsRecognSerialiser::serialiseReq() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsGxsRecognReqItem *RsGxsRecognSerialiser::deserialiseReq(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t tlvsize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_GXS_RECOGN != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_RECOGN_REQ != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < tlvsize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = tlvsize; - - bool ok = true; - - /* ready to load */ - RsGxsRecognReqItem *item = new RsGxsRecognReqItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= getRawUInt32(data, tlvsize, &offset, &(item->issued_at)); - ok &= getRawUInt32(data, tlvsize, &offset, &(item->period)); - ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_class)); - ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_type)); - - - ok &= item->identity.serialise(data, tlvsize, offset); - ok &= GetTlvString(data, tlvsize, &offset, 1, item->nickname); - ok &= GetTlvString(data, tlvsize, &offset, 1, item->comment); - ok &= item->sign.GetTlv(data, tlvsize, &offset); - - - if (offset != tlvsize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ - -RsGxsRecognTagItem::~RsGxsRecognTagItem() -{ - return; -} -#endif - void RsGxsRecognTagItem::clear() { valid_from = 0; @@ -264,56 +89,6 @@ void RsGxsRecognTagItem::clear() sign.TlvClear(); } -#ifdef TO_REMOVE -std::ostream &RsGxsRecognTagItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsRecognTagItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "valid_from: " << valid_from << std::endl; - - printIndent(out, int_Indent); - out << "valid_to: " << valid_to << std::endl; - - printIndent(out, int_Indent); - out << "tag_class: " << tag_class << std::endl; - - printIndent(out, int_Indent); - out << "tag_type: " << tag_type << std::endl; - - printIndent(out, int_Indent); - out << "identity: " << identity << std::endl; - - printIndent(out, int_Indent); - out << "nickname: " << nickname << std::endl; - - printIndent(out, int_Indent); - out << "signature: " << std::endl; - sign.print(out, int_Indent + 2); - - printRsItemEnd(out, "RsGxsRecognTagItem", indent); - return out; -} - - -uint32_t RsGxsRecognSerialiser::sizeTag(RsGxsRecognTagItem *item) -{ - uint32_t s = 8; /* header */ - s += 4; // valid_from; - s += 4; // valid_to; - s += 2; // tag_class; - s += 2; // tag_type; - - s += item->identity.serial_size(); - s += GetTlvStringSize(item->nickname); - - s += item->sign.TlvSize(); - - return s; -} -#endif - void RsGxsRecognTagItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process (j,ctx,valid_from ,"valid_from") ; @@ -325,122 +100,6 @@ void RsGxsRecognTagItem::serial_process(RsGenericSerializer::SerializeJob j,RsGe RsTypeSerializer::serial_process(j,ctx,sign ,"sign") ; } -#ifdef TO_REMOVE -/* serialise the data to the buffer */ -bool RsGxsRecognSerialiser::serialiseTag(RsGxsRecognTagItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeTag(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsRecognSerialiser::serialiseTag() Header: " << ok << std::endl; - std::cerr << "RsGxsRecognSerialiser::serialiseTag() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, item->valid_from); - ok &= setRawUInt32(data, tlvsize, &offset, item->valid_to); - - ok &= setRawUInt16(data, tlvsize, &offset, item->tag_class); - ok &= setRawUInt16(data, tlvsize, &offset, item->tag_type); - - - ok &= item->identity.serialise(data, tlvsize, offset); - ok &= SetTlvString(data, tlvsize, &offset, 1, item->nickname); - - ok &= item->sign.SetTlv(data, tlvsize, &offset); - - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsRecognSerialiser::serialiseTag() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsGxsRecognTagItem *RsGxsRecognSerialiser::deserialiseTag(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t tlvsize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_GXS_RECOGN != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_RECOGN_TAG != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < tlvsize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = tlvsize; - - bool ok = true; - - /* ready to load */ - RsGxsRecognTagItem *item = new RsGxsRecognTagItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= getRawUInt32(data, tlvsize, &offset, &(item->valid_from)); - ok &= getRawUInt32(data, tlvsize, &offset, &(item->valid_to)); - - ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_class)); - ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_type)); - - - ok &= item->identity.deserialise(data, tlvsize, offset); - ok &= GetTlvString(data, tlvsize, &offset, 1, item->nickname); - ok &= item->sign.GetTlv(data, tlvsize, &offset); - - - if (offset != tlvsize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ - -RsGxsRecognSignerItem::~RsGxsRecognSignerItem() -{ - return; -} -#endif - void RsGxsRecognSignerItem::clear() { signing_classes.TlvClear(); @@ -448,43 +107,6 @@ void RsGxsRecognSignerItem::clear() sign.TlvClear(); } -#ifdef TO_REMOVE -std::ostream &RsGxsRecognSignerItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsRecognSignerItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "signing_classes: " << std::endl; - signing_classes.print(out, int_Indent + 2); - - printIndent(out, int_Indent); - out << "key: " << std::endl; - key.print(out, int_Indent + 2); - - printIndent(out, int_Indent); - out << "signature: " << std::endl; - sign.print(out, int_Indent + 2); - - - printRsItemEnd(out, "RsGxsRecognSignerItem", indent); - return out; -} - - - - -uint32_t RsGxsRecognSerialiser::sizeSigner(RsGxsRecognSignerItem *item) -{ - uint32_t s = 8; /* header */ - s += item->signing_classes.TlvSize(); - s += item->key.TlvSize(); - s += item->sign.TlvSize(); - - return s; -} -#endif - void RsGxsRecognSignerItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,signing_classes ,"signing_classes") ; @@ -492,175 +114,5 @@ void RsGxsRecognSignerItem::serial_process(RsGenericSerializer::SerializeJob j,R RsTypeSerializer::serial_process(j,ctx,sign ,"sign") ; } -#ifdef TO_REMOVE -/* serialise the data to the buffer */ -bool RsGxsRecognSerialiser::serialiseSigner(RsGxsRecognSignerItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeSigner(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsRecognSerialiser::serialiseSigner() Header: " << ok << std::endl; - std::cerr << "RsGxsRecognSerialiser::serialiseSigner() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->signing_classes.SetTlv(data, tlvsize, &offset); - ok &= item->key.SetTlv(data, tlvsize, &offset); - ok &= item->sign.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsGxsRecognSerialiser::serialiseSigner() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsGxsRecognSignerItem *RsGxsRecognSerialiser::deserialiseSigner(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t tlvsize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_GXS_RECOGN != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_RECOGN_SIGNER != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < tlvsize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = tlvsize; - - bool ok = true; - - /* ready to load */ - RsGxsRecognSignerItem *item = new RsGxsRecognSignerItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= item->signing_classes.GetTlv(data, tlvsize, &offset); - ok &= item->key.GetTlv(data, tlvsize, &offset); - ok &= item->sign.GetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - - -/*************************************************************************/ - -uint32_t RsGxsRecognSerialiser::size(RsItem *i) -{ - RsGxsRecognReqItem *rqi; - RsGxsRecognTagItem *rti; - RsGxsRecognSignerItem *rsi; - - if (NULL != (rqi = dynamic_cast(i))) - { - return sizeReq(rqi); - } - if (NULL != (rti = dynamic_cast(i))) - { - return sizeTag(rti); - } - if (NULL != (rsi = dynamic_cast(i))) - { - return sizeSigner(rsi); - } - return 0; -} - -bool RsGxsRecognSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ - RsGxsRecognReqItem *rri; - RsGxsRecognTagItem *rti; - RsGxsRecognSignerItem *rsi; - - if (NULL != (rri = dynamic_cast(i))) - { - return serialiseReq(rri, data, pktsize); - } - if (NULL != (rti = dynamic_cast(i))) - { - return serialiseTag(rti, data, pktsize); - } - if (NULL != (rsi = dynamic_cast(i))) - { - return serialiseSigner(rsi, data, pktsize); - } - return false; -} - -RsItem *RsGxsRecognSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - if (*pktsize < getRsPktBaseSize()) - return NULL ; - - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_GXS_RECOGN != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_RECOGN_REQ: - return deserialiseReq(data, pktsize); - break; - case RS_PKT_SUBTYPE_RECOGN_TAG: - return deserialiseTag(data, pktsize); - break; - case RS_PKT_SUBTYPE_RECOGN_SIGNER: - return deserialiseSigner(data, pktsize); - break; - default: - return NULL; - break; - } -} - -/*************************************************************************/ -#endif diff --git a/libretroshare/src/rsitems/rsgxsreputationitems.cc b/libretroshare/src/rsitems/rsgxsreputationitems.cc index 2a559b052..7b558131a 100644 --- a/libretroshare/src/rsitems/rsgxsreputationitems.cc +++ b/libretroshare/src/rsitems/rsgxsreputationitems.cc @@ -88,525 +88,6 @@ void RsGxsReputationRequestItem::serial_process(RsGenericSerializer::SerializeJo RsTypeSerializer::serial_process(j,ctx,mLastUpdate,"mLastUpdate") ; } -#ifdef TO_REMOVE -// re-defined here, in order to avoid cross-includes -#define REPUTATION_IDENTITY_FLAG_NEEDS_UPDATE 0x0100 - -/*************************************************************************/ -/*************************************************************************/ -/*************************************************************************/ - -std::ostream& RsGxsReputationConfigItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsReputationConfigItem", indent); - - out << "mPeerId: " << mPeerId << std::endl; - out << "last update: " << time(NULL) - mLatestUpdate << " secs ago." << std::endl; - out << "last query : " << time(NULL) - mLastQuery << " secs ago." << std::endl; - - printRsItemEnd(out, "RsReputationConfigItem", indent); - return out; -} - -std::ostream& RsGxsReputationSetItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsReputationSetItem", indent); - - out << "GxsId: " << mGxsId << std::endl; - out << "Owner: " << mOwnerNodeId << std::endl; - out << "mOwnOpinion: " << mOwnOpinion << std::endl; - out << "mOwnOpinionTS : " << time(NULL) - mOwnOpinionTS << " secs ago." << std::endl; - out << "Opinions from neighbors: " << std::endl; - - for(std::map::const_iterator it(mOpinions.begin());it!=mOpinions.end();++it) - out << " " << it->first << ": " << it->second << std::endl; - - printRsItemEnd(out, "RsReputationSetItem", indent); - return out; -} -std::ostream& RsGxsReputationUpdateItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsReputationUpdateItem", indent); - - out << "from: " << PeerId() << std::endl; - out << "last update: " << time(NULL) - mLatestUpdate << " secs ago." << std::endl; - - for(std::map::const_iterator it(mOpinions.begin());it!=mOpinions.end();++it) - out << " " << it->first << ": " << it->second << std::endl; - - printRsItemEnd(out, "RsReputationUpdateItem", indent); - return out; -} -std::ostream& RsGxsReputationRequestItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsReputationRequestItem", indent); - - out << "last update: " << time(NULL) - mLastUpdate << " secs ago." << std::endl; - - printRsItemEnd(out, "RsReputationRequestItem", indent); - return out; -} -std::ostream& RsGxsReputationBannedNodeSetItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsReputationBannedNodeSetItem", indent); - - out << "last update: " << time(NULL) - mLastActivityTS << " secs ago." << std::endl; - out << "PGP id: " << mPgpId << std::endl; - out << "Known ids: " << mKnownIdentities.ids.size() << std::endl; - - printRsItemEnd(out, "RsReputationRequestItem", indent); - return out; -} -/*************************************************************************/ - -uint32_t RsGxsReputationConfigItem::serial_size() const -{ - uint32_t s = 8; /* header */ - - s += mPeerId.serial_size() ; // PeerId - s += 4 ; // mLatestUpdate - s += 4 ; // mLastQuery - - return s ; -} - -uint32_t RsGxsReputationSetItem::serial_size() const -{ - uint32_t s = 8; /* header */ - - s += mGxsId.serial_size() ; - s += 4 ; // mOwnOpinion - s += 4 ; // mOwnOpinionTS - s += 4 ; // mIdentityFlags - s += 4 ; // mLastUsedTS - s += mOwnerNodeId.serial_size() ; - - s += 4 ; // mOpinions.size() - - s += (4+RsPeerId::serial_size()) * mOpinions.size() ; - - return s ; -} - -uint32_t RsGxsReputationBannedNodeSetItem::serial_size() const -{ - uint32_t s = 8; /* header */ - - s += RsPgpId::serial_size() ; // mPgpId - s += 4 ; // mLastActivityTS; - s += mKnownIdentities.TlvSize(); // mKnownIdentities - - return s ; -} - -uint32_t RsGxsReputationUpdateItem::serial_size() const -{ - uint32_t s = 8; /* header */ - - s += 4 ; // mLatestUpdate - s += 4 ; // mOpinions.size(); - - s += (RsGxsId::serial_size() + 4) * mOpinions.size() ; - - return s ; -} - -uint32_t RsGxsReputationRequestItem::serial_size() const -{ - uint32_t s = 8; /* header */ - - s += 4 ; // mLastUpdate - - return s; -} - -/*************************************************************************/ - -bool RsGxsReputationConfigItem::serialise(void *data, uint32_t& pktsize) const -{ - uint32_t tlvsize ; - uint32_t offset=0; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - bool ok = true; - - ok &= mPeerId.serialise(data,tlvsize,offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, mLatestUpdate); - ok &= setRawUInt32(data, tlvsize, &offset, mLastQuery); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGxsReputationConfigItem::serialisedata() size error! " << std::endl; - } - - return ok; -} - -bool RsGxsReputationSetItem::serialise(void *data, uint32_t& pktsize) const -{ - uint32_t tlvsize ; - uint32_t offset=0; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - bool ok = true; - - ok &= mGxsId.serialise(data,tlvsize,offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, mOwnOpinion); - ok &= setRawUInt32(data, tlvsize, &offset, mOwnOpinionTS); - ok &= setRawUInt32(data, tlvsize, &offset, mIdentityFlags) ; - ok &= setRawUInt32(data, tlvsize, &offset, mLastUsedTS) ; - ok &= mOwnerNodeId.serialise(data,tlvsize,offset) ; - - ok &= setRawUInt32(data, tlvsize, &offset, mOpinions.size()); - - for(std::map::const_iterator it(mOpinions.begin());it!=mOpinions.end();++it) - { - ok &= it->first.serialise(data,tlvsize,offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, it->second) ; - } - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGxsReputationSetItem::serialisedata() size error! " << std::endl; - } - - return ok; -} - -bool RsGxsReputationBannedNodeSetItem::serialise(void *data, uint32_t& pktsize) const -{ - uint32_t tlvsize ; - uint32_t offset=0; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - bool ok = true; - - ok &= mPgpId.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, mLastActivityTS); - ok &= mKnownIdentities.SetTlv(data, tlvsize, &offset) ; - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGxsReputationSetItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -bool RsGxsReputationUpdateItem::serialise(void *data, uint32_t& pktsize) const -{ - uint32_t tlvsize ; - uint32_t offset=0; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - bool ok = true; - - ok &= setRawUInt32(data, tlvsize, &offset, mLatestUpdate); - ok &= setRawUInt32(data, tlvsize, &offset, mOpinions.size()); - - for(std::map::const_iterator it(mOpinions.begin());ok && it!=mOpinions.end();++it) - { - ok &= it->first.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, it->second) ; - } - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGxsReputationUpdateItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -/* serialise the data to the buffer */ -bool RsGxsReputationRequestItem::serialise(void *data, uint32_t& pktsize) const -{ - uint32_t tlvsize ; - uint32_t offset=0; - - if(!serialise_header(data,pktsize,tlvsize,offset)) - return false ; - - bool ok = true; - - ok &= setRawUInt32(data, tlvsize, &offset, mLastUpdate); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsGxsReputationRequestItem::serialisedata() size error! " << std::endl; - } - - return ok; -} -/*************************************************************************/ - -RsGxsReputationConfigItem *RsGxsReputationSerialiser::deserialiseReputationConfigItem(void *data,uint32_t size) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGxsReputationConfigItem *item = new RsGxsReputationConfigItem() ; - - /* add mandatory parts first */ - ok &= item->mPeerId.deserialise(data, size, offset) ; - ok &= getRawUInt32(data, size, &offset, &item->mLatestUpdate); - ok &= getRawUInt32(data, size, &offset, &item->mLastQuery); - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} - -RsGxsReputationBannedNodeSetItem *RsGxsReputationSerialiser::deserialiseReputationBannedNodeSetItem(void *data,uint32_t size) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGxsReputationBannedNodeSetItem *item = new RsGxsReputationBannedNodeSetItem() ; - - /* add mandatory parts first */ - ok &= item->mPgpId.deserialise(data, size, offset) ; - ok &= getRawUInt32(data, size, &offset, &item->mLastActivityTS); - ok &= item->mKnownIdentities.GetTlv(data,size,&offset) ; - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} - - -RsGxsReputationSetItem *RsGxsReputationSerialiser::deserialiseReputationSetItem_deprecated(void *data,uint32_t tlvsize) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGxsReputationSetItem *item = new RsGxsReputationSetItem() ; - - /* add mandatory parts first */ - ok &= item->mGxsId.deserialise(data, tlvsize, offset) ; - - item->mOwnerNodeId.clear(); // clears up, for backward compat. - - ok &= getRawUInt32(data, tlvsize, &offset, &item->mOwnOpinion); - ok &= getRawUInt32(data, tlvsize, &offset, &item->mOwnOpinionTS); - ok &= getRawUInt32(data, tlvsize, &offset, &item->mIdentityFlags); - - uint32_t S ; - ok &= getRawUInt32(data, tlvsize, &offset, &S); - - for(uint32_t i = 0; ok && (i < S); ++i) - { - RsPeerId pid ; - uint32_t op ; - - ok &= pid.deserialise(data, tlvsize, offset) ; - ok &= getRawUInt32(data, tlvsize, &offset, &op); - - if(ok) - item->mOpinions[pid] = op ; - } - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -RsGxsReputationSetItem_deprecated3 *RsGxsReputationSerialiser::deserialiseReputationSetItem_deprecated3(void *data,uint32_t tlvsize) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGxsReputationSetItem_deprecated3 *item = new RsGxsReputationSetItem_deprecated3() ; - - /* add mandatory parts first */ - ok &= item->mGxsId.deserialise(data, tlvsize, offset) ; - ok &= getRawUInt32(data, tlvsize, &offset, &item->mOwnOpinion); - ok &= getRawUInt32(data, tlvsize, &offset, &item->mOwnOpinionTS); - ok &= getRawUInt32(data, tlvsize, &offset, &item->mIdentityFlags); - ok &= item->mOwnerNodeId.deserialise(data, tlvsize, offset) ; - - uint32_t S ; - ok &= getRawUInt32(data, tlvsize, &offset, &S); - - for(uint32_t i = 0; ok && (i < S); ++i) - { - RsPeerId pid ; - uint32_t op ; - - ok &= pid.deserialise(data, tlvsize, offset) ; - ok &= getRawUInt32(data, tlvsize, &offset, &op); - - if(ok) - item->mOpinions[pid] = op ; - } - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} -RsGxsReputationSetItem *RsGxsReputationSerialiser::deserialiseReputationSetItem(void *data,uint32_t tlvsize) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGxsReputationSetItem *item = new RsGxsReputationSetItem() ; - - /* add mandatory parts first */ - ok &= item->mGxsId.deserialise(data, tlvsize, offset) ; - ok &= getRawUInt32(data, tlvsize, &offset, &item->mOwnOpinion); - ok &= getRawUInt32(data, tlvsize, &offset, &item->mOwnOpinionTS); - ok &= getRawUInt32(data, tlvsize, &offset, &item->mIdentityFlags); - ok &= getRawUInt32(data, tlvsize, &offset, &item->mLastUsedTS); - ok &= item->mOwnerNodeId.deserialise(data, tlvsize, offset) ; - - uint32_t S ; - ok &= getRawUInt32(data, tlvsize, &offset, &S); - - for(uint32_t i = 0; ok && (i < S); ++i) - { - RsPeerId pid ; - uint32_t op ; - - ok &= pid.deserialise(data, tlvsize, offset) ; - ok &= getRawUInt32(data, tlvsize, &offset, &op); - - if(ok) - item->mOpinions[pid] = op ; - } - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} - -RsGxsReputationUpdateItem *RsGxsReputationSerialiser::deserialiseReputationUpdateItem(void *data,uint32_t tlvsize) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGxsReputationUpdateItem *item = new RsGxsReputationUpdateItem() ; - - /* add mandatory parts first */ - ok &= getRawUInt32(data, tlvsize, &offset, &item->mLatestUpdate); - - uint32_t S ; - ok &= getRawUInt32(data, tlvsize, &offset, &S) ; - - for(uint32_t i=0;ok && imOpinions[gid] = op ; - - } - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} - -RsGxsReputationRequestItem *RsGxsReputationSerialiser::deserialiseReputationRequestItem(void *data,uint32_t tlvsize) -{ - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; - - RsGxsReputationRequestItem *item = new RsGxsReputationRequestItem() ; - - /* add mandatory parts first */ - ok &= getRawUInt32(data, tlvsize, &offset, &item->mLastUpdate); - - if (offset != rssize || !ok) - { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } - - return item; -} - -/*************************************************************************/ - -RsItem *RsGxsReputationSerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_GXS_TYPE_REPUTATION != getRsItemService(rstype))) - { - std::cerr << "RsReputationSerialiser::deserialise(): wrong item type " << std::hex << rstype << std::dec << std::endl; - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM : return deserialiseReputationSetItem (data, *pktsize); - case RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM_deprecated3: return deserialiseReputationSetItem_deprecated3(data, *pktsize); - case RS_PKT_SUBTYPE_GXS_REPUTATION_BANNED_NODE_SET_ITEM: return deserialiseReputationBannedNodeSetItem (data, *pktsize); - case RS_PKT_SUBTYPE_GXS_REPUTATION_UPDATE_ITEM : return deserialiseReputationUpdateItem (data, *pktsize); - case RS_PKT_SUBTYPE_GXS_REPUTATION_REQUEST_ITEM : return deserialiseReputationRequestItem (data, *pktsize); - case RS_PKT_SUBTYPE_GXS_REPUTATION_CONFIG_ITEM : return deserialiseReputationConfigItem (data, *pktsize); - - default: - std::cerr << "RsGxsReputationSerialiser::deserialise(): unknown item subtype " << std::hex<< rstype << std::dec << std::endl; - return NULL; - break; - } -} -#endif - /*************************************************************************/ RsItem *RsGxsReputationSerialiser::create_item(uint16_t service,uint8_t subtype) const diff --git a/libretroshare/src/rsitems/rshistoryitems.cc b/libretroshare/src/rsitems/rshistoryitems.cc index 3280f8eba..23aa9e38f 100644 --- a/libretroshare/src/rsitems/rshistoryitems.cc +++ b/libretroshare/src/rsitems/rshistoryitems.cc @@ -72,225 +72,4 @@ RsHistoryMsgItem::RsHistoryMsgItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONF saveToDisc = true; } -#ifdef TO_REMOVE -/*************************************************************************/ -RsHistoryMsgItem::~RsHistoryMsgItem() -{ -} - -void RsHistoryMsgItem::clear() -{ - incoming = false; - peerId.clear(); - peerName.clear(); - sendTime = 0; - recvTime = 0; - message.clear(); - msgId = 0; - saveToDisc = true; -} - -std::ostream& RsHistoryMsgItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsHistoryMsgItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "chatPeerid: " << chatPeerId << std::endl; - - printIndent(out, int_Indent); - out << "incoming: " << (incoming ? "1" : "0") << std::endl; - - printIndent(out, int_Indent); - out << "peerId: " << peerId << std::endl; - - printIndent(out, int_Indent); - out << "peerName: " << peerName << std::endl; - - printIndent(out, int_Indent); - out << "sendTime: " << sendTime << std::endl; - - printIndent(out, int_Indent); - out << "recvTime: " << recvTime << std::endl; - - printIndent(out, int_Indent); - std::string cnv_message(message.begin(), message.end()); - out << "message: " << cnv_message << std::endl; - - printRsItemEnd(out, "RsHistoryMsgItem", indent); - return out; -} - - -RsHistorySerialiser::~RsHistorySerialiser() -{ -} - -uint32_t RsHistorySerialiser::sizeHistoryMsgItem(RsHistoryMsgItem* item) -{ - uint32_t s = 8; /* header */ - s += 2; /* version */ - s += item->chatPeerId.serial_size(); - s += 1; /* incoming */ - s += item->peerId.serial_size(); - s += GetTlvStringSize(item->peerName); - s += 4; /* sendTime */ - s += 4; /* recvTime */ - s += GetTlvStringSize(item->message); - - return s; -} -/* serialise the data to the buffer */ -bool RsHistorySerialiser::serialiseHistoryMsgItem(RsHistoryMsgItem* item, void* data, uint32_t* pktsize) -{ - uint32_t tlvsize = sizeHistoryMsgItem(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsHistorySerialiser::serialiseItem() Header: " << ok << std::endl; - std::cerr << "RsHistorySerialiser::serialiseItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt16(data, tlvsize, &offset, 0); // version - ok &= item->chatPeerId.serialise(data, tlvsize, offset) ; - uint8_t dummy = item->incoming ? 1 : 0; - ok &= setRawUInt8(data, tlvsize, &offset, dummy); - ok &= item->peerId.serialise(data, tlvsize, offset) ; - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->peerName); - ok &= setRawUInt32(data, tlvsize, &offset, item->sendTime); - ok &= setRawUInt32(data, tlvsize, &offset, item->recvTime); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->message); - - if (offset != tlvsize) - { - ok = false; -#ifdef RSSERIAL_DEBUG - std::cerr << "RsHistorySerialiser::serialiseItem() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsHistoryMsgItem *RsHistorySerialiser::deserialiseHistoryMsgItem(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_HISTORY_CONFIG != getRsItemType(rstype)) || - (RS_PKT_SUBTYPE_DEFAULT != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsHistoryMsgItem *item = new RsHistoryMsgItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - uint16_t version = 0; - ok &= getRawUInt16(data, rssize, &offset, &version); - ok &= item->chatPeerId.deserialise(data, rssize, offset) ; - uint8_t dummy; - ok &= getRawUInt8(data, rssize, &offset, &dummy); - item->incoming = (dummy == 1); - ok &= item->peerId.deserialise(data, rssize, offset) ; - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->peerName); - ok &= getRawUInt32(data, rssize, &offset, &(item->sendTime)); - ok &= getRawUInt32(data, rssize, &offset, &(item->recvTime)); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->message); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -uint32_t RsHistorySerialiser::size(RsItem *item) -{ - RsHistoryMsgItem* hi; - - if (NULL != (hi = dynamic_cast(item))) - { - return sizeHistoryMsgItem(hi); - } - - return 0; -} - -bool RsHistorySerialiser::serialise(RsItem *item, void *data, uint32_t *pktsize) -{ - RsHistoryMsgItem* hi; - - if (NULL != (hi = dynamic_cast(item))) - { - return serialiseHistoryMsgItem(hi, data, pktsize); - } - - return false; -} - -RsItem* RsHistorySerialiser::deserialise(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) || - (RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) || - (RS_PKT_TYPE_HISTORY_CONFIG != getRsItemType(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_DEFAULT: - return deserialiseHistoryMsgItem(data, pktsize); - } - - return NULL; -} - -/*************************************************************************/ - -#endif diff --git a/libretroshare/src/rsitems/rsnxsitems.cc b/libretroshare/src/rsitems/rsnxsitems.cc index d6eb8b143..104935930 100644 --- a/libretroshare/src/rsitems/rsnxsitems.cc +++ b/libretroshare/src/rsitems/rsnxsitems.cc @@ -212,1199 +212,4 @@ void RsNxsSessionKeyItem::clear() } #endif -#ifdef TO_REMOVE -uint32_t RsNxsSerialiser::size(RsItem *item) -{ - RsNxsItem *nxs_item = dynamic_cast(item) ; - - if(nxs_item != NULL) - return nxs_item->serial_size() ; - else - { - std::cerr << "RsNxsSerialiser::serialise(): Not an RsNxsItem!" << std::endl; - return 0; - } -} - -bool RsNxsSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ - RsNxsItem *nxs_item = dynamic_cast(item) ; - - if(nxs_item != NULL) - return nxs_item->serialise(data,*size) ; - else - { - std::cerr << "RsNxsSerialiser::serialise(): Not an RsNxsItem!" << std::endl; - return 0; - } -} - -bool RsNxsItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const -{ - tlvsize = serial_size() ; - offset = 0; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize; - - if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize)) - { - std::cerr << "RsFileTransferItem::serialise_header(): ERROR. Not enough size!" << std::endl; - return false ; - } -#ifdef RSSERIAL_DEBUG - std::cerr << "RsFileItemSerialiser::serialiseData() Header: " << ok << std::endl; -#endif - offset += 8; - - return true ; -} - -bool RsNxsSyncMsgItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem()" << std::endl; -#endif - - /* RsNxsSyncMsgItem */ - - ok &= setRawUInt32(data, size, &offset, transactionNumber); - ok &= setRawUInt8(data, size, &offset, flag); - ok &= grpId.serialise(data, size, offset); - ok &= msgId.serialise(data, size, offset); - ok &= authorId.serialise(data, size, offset); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem() NOK" << std::endl; - } -#endif - - return ok; -} - -bool RsNxsMsg::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= setRawUInt32(data, size, &offset, transactionNumber); - ok &= setRawUInt8(data, size, &offset, pos); - ok &= msgId.serialise(data, size, offset); - ok &= grpId.serialise(data, size, offset); - ok &= msg.SetTlv(data, size, &offset); - ok &= meta.SetTlv(data, size, &offset); - - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseNxsMsg() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsNxsSerialiser::serialiseNxsMsg() NOK" << std::endl; - } -#endif - - return ok; -} - - -bool RsNxsGrp::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - // grp id - ok &= setRawUInt32(data, size, &offset, transactionNumber); - ok &= setRawUInt8(data, size, &offset, pos); - ok &= grpId.serialise(data, size, offset); - ok &= grp.SetTlv(data, size, &offset); - ok &= meta.SetTlv(data, size, &offset); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseNxsGrp() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsNxsSerialiser::serialiseNxsGrp() NOK" << std::endl; - } -#endif - - return ok; -} -bool RsNxsSyncGrpStatsItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpStats()" << std::endl; -#endif - - ok &= setRawUInt32(data, size, &offset, request_type); - ok &= grpId.serialise(data, size, offset) ; - ok &= setRawUInt32(data, size, &offset, number_of_posts); - ok &= setRawUInt32(data, size, &offset, last_post_TS); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSyncGrpStats() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsNxsSerialiser::serialiseSyncGrpStats() NOK" << std::endl; - } -#endif - - return ok; -} -bool RsNxsSyncGrpReqItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= setRawUInt32(data, size, &offset, transactionNumber); - ok &= setRawUInt8(data, size, &offset, flag); - ok &= setRawUInt32(data, size, &offset, createdSince); - ok &= SetTlvString(data, size, &offset, TLV_TYPE_STR_HASH_SHA1, syncHash); - ok &= setRawUInt32(data, size, &offset, updateTS); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSyncGrp() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsNxsSerialiser::serialiseSyncGrp() NOK" << std::endl; - } -#endif - - return ok; -} - -bool RsNxsTransacItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= setRawUInt32(data, size, &offset, transactionNumber); - ok &= setRawUInt16(data, size, &offset, transactFlag); - ok &= setRawUInt32(data, size, &offset, nItems); - ok &= setRawUInt32(data, size, &offset, updateTS); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseNxsTrans() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsNxsSerialiser::serialiseNxsTrans() NOK" << std::endl; - } -#endif - - return ok; -} - -bool RsNxsSyncGrpItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - /* RsNxsSyncm */ - - ok &= setRawUInt32(data, size, &offset, transactionNumber); - ok &= setRawUInt8(data, size, &offset, flag); - ok &= grpId.serialise(data, size, offset); - ok &= setRawUInt32(data, size, &offset, publishTs); - ok &= authorId.serialise(data, size, offset); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseNxsSyncm( FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsNxsSerialiser::serialiseNxsSyncm() NOK" << std::endl; - } -#endif - - return ok; -} - - -bool RsNxsSyncMsgReqItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= setRawUInt32(data, size, &offset, transactionNumber); - ok &= setRawUInt8(data, size, &offset, flag); - ok &= setRawUInt32(data, size, &offset, createdSinceTS); - ok &= SetTlvString(data, size, &offset, TLV_TYPE_STR_HASH_SHA1, syncHash); - ok &= grpId.serialise(data, size, offset); - ok &= setRawUInt32(data, size, &offset, updateTS); - - if(offset != tlvsize){ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef RSSERIAL_DEBUG - if (!ok) - { - std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg( NOK" << std::endl; - } -#endif - - return ok; -} - - -bool RsNxsGroupPublishKeyItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= grpId.serialise(data, size, offset) ; - ok &= private_key.SetTlv(data, size, &offset) ; - - if(offset != tlvsize) - { - std::cerr << "RsNxsSerialiser::serialiseGroupPublishKeyItem() FAIL Size Error! " << std::endl; - ok = false; - } - - if (!ok) - std::cerr << "RsNxsSerialiser::serialiseGroupPublishKeyItem( NOK" << std::endl; - - return ok; -} - -bool RsNxsSessionKeyItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= setRawUInt32(data, size, &offset, transactionNumber); - - if(offset + EVP_MAX_IV_LENGTH >= size) - { - std::cerr << "RsNxsSessionKeyItem::serialize(): error. Not enough room for IV !" << std::endl; - return false ; - } - memcpy(&((uint8_t*)data)[offset],iv,EVP_MAX_IV_LENGTH) ; - offset += EVP_MAX_IV_LENGTH ; - - ok &= setRawUInt32(data, size, &offset, encrypted_session_keys.size()); - - for(std::map::const_iterator it(encrypted_session_keys.begin());it!=encrypted_session_keys.end();++it) - { - ok &= it->first.serialise(data, size, offset) ; - ok &= it->second.SetTlv(data, size, &offset) ; - } - - if(offset != tlvsize) - { - std::cerr << "RsNxsSerialiser::serialiseGroupPublishKeyItem() FAIL Size Error! " << std::endl; - ok = false; - } - - if (!ok) - std::cerr << "RsNxsSerialiser::serialiseGroupPublishKeyItem( NOK" << std::endl; - - return ok; -} -bool RsNxsEncryptedDataItem::serialise(void *data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - bool ok = true; - - if(!serialise_header(data,size,tlvsize,offset)) - return false ; - - ok &= setRawUInt32(data, size, &offset, transactionNumber); - ok &= encrypted_data.SetTlv(data, size, &offset) ; - - if(offset != tlvsize) - { - std::cerr << "RsNxsSerialiser::serialiseGroupPublishKeyItem() FAIL Size Error! " << std::endl; - ok = false; - } - - if (!ok) - std::cerr << "RsNxsSerialiser::serialiseGroupPublishKeyItem( NOK" << std::endl; - - return ok; -} - - - -/*** deserialisation ***/ - -RsNxsGrp* RsNxsSerialiser::deserialNxsGrpItem(void *data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_GRP_ITEM); - uint32_t offset = 8; - - RsNxsGrp* item = new RsNxsGrp(SERVICE_TYPE); - - /* skip the header */ - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - ok &= getRawUInt8(data, *size, &offset, &(item->pos)); - ok &= item->grpId.deserialise(data, *size, offset); - ok &= item->grp.GetTlv(data, *size, &offset); - ok &= item->meta.GetTlv(data, *size, &offset); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsGrp() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsGrp() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -RsNxsMsg* RsNxsSerialiser::deserialNxsMsgItem(void *data, uint32_t *size){ - - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_MSG_ITEM); - uint32_t offset = 8; - - RsNxsMsg* item = new RsNxsMsg(SERVICE_TYPE); - /* skip the header */ - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - ok &= getRawUInt8(data, *size, &offset, &(item->pos)); - ok &= item->msgId.deserialise(data, *size, offset); - ok &= item->grpId.deserialise(data, *size, offset); - ok &= item->msg.GetTlv(data, *size, &offset); - ok &= item->meta.GetTlv(data, *size, &offset); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsMsg() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsMsg() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -RsNxsSyncGrpStatsItem* RsNxsSerialiser::deserialNxsSyncGrpStatsItem(void *data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_SYNC_GRP_STATS_ITEM); - uint32_t offset = 8; - - RsNxsSyncGrpStatsItem* item = new RsNxsSyncGrpStatsItem(SERVICE_TYPE) ; - /* skip the header */ - - ok &= getRawUInt32(data, *size, &offset, &(item->request_type)); - ok &= item->grpId.deserialise(data, *size, offset) ; - ok &= getRawUInt32(data, *size, &offset, &(item->number_of_posts)); - ok &= getRawUInt32(data, *size, &offset, &(item->last_post_TS)); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpStats() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpStats() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - - -bool RsNxsSerialiser::checkItemHeader(void *data,uint32_t *size,uint8_t subservice_type) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::checkItemHeader()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (SERVICE_TYPE != getRsItemService(rstype)) || (subservice_type != getRsItemSubType(rstype))) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::checkItemHeader() FAIL wrong type" << std::endl; -#endif - return false; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::checkItemHeader() FAIL wrong size" << std::endl; -#endif - return false; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - return true ; -} - -RsNxsSyncGrpReqItem* RsNxsSerialiser::deserialNxsSyncGrpReqItem(void *data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_SYNC_GRP_REQ_ITEM); - - RsNxsSyncGrpReqItem* item = new RsNxsSyncGrpReqItem(SERVICE_TYPE); - /* skip the header */ - uint32_t offset = 8; - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - ok &= getRawUInt8(data, *size, &offset, &(item->flag)); - ok &= getRawUInt32(data, *size, &offset, &(item->createdSince)); - ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash); - ok &= getRawUInt32(data, *size, &offset, &(item->updateTS)); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -RsNxsSyncGrpItem* RsNxsSerialiser::deserialNxsSyncGrpItem(void *data, uint32_t *size){ - - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM); - - RsNxsSyncGrpItem* item = new RsNxsSyncGrpItem(SERVICE_TYPE); - /* skip the header */ - uint32_t offset = 8; - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - ok &= getRawUInt8(data, *size, &offset, &(item->flag)); - ok &= item->grpId.deserialise(data, *size, offset); - ok &= getRawUInt32(data, *size, &offset, &(item->publishTs)); - ok &= item->authorId.deserialise(data, *size, offset); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -RsNxsTransacItem* RsNxsSerialiser::deserialNxsTransacItem(void *data, uint32_t *size){ - - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_TRANSAC_ITEM); - uint32_t offset = 8 ; - - RsNxsTransacItem* item = new RsNxsTransacItem(SERVICE_TYPE); - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - ok &= getRawUInt16(data, *size, &offset, &(item->transactFlag)); - ok &= getRawUInt32(data, *size, &offset, &(item->nItems)); - ok &= getRawUInt32(data, *size, &offset, &(item->updateTS)); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsTrans() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsTrans() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; - - -} - -RsNxsSyncMsgItem* RsNxsSerialiser::deserialNxsSyncMsgItem(void *data, uint32_t *size){ - - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM); - uint32_t offset = 8 ; - - RsNxsSyncMsgItem* item = new RsNxsSyncMsgItem(SERVICE_TYPE); - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - ok &= getRawUInt8(data, *size, &offset, &(item->flag)); - ok &= item->grpId.deserialise(data, *size, offset); - ok &= item->msgId.deserialise(data, *size, offset); - ok &= item->authorId.deserialise(data, *size, offset); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -RsNxsSyncMsgReqItem* RsNxsSerialiser::deserialNxsSyncMsgReqItem(void *data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_SYNC_MSG_REQ_ITEM); - uint32_t offset = 8 ; - - RsNxsSyncMsgReqItem* item = new RsNxsSyncMsgReqItem(SERVICE_TYPE); - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - ok &= getRawUInt8(data, *size, &offset, &(item->flag)); - ok &= getRawUInt32(data, *size, &offset, &(item->createdSinceTS)); - ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash); - ok &= item->grpId.deserialise(data, *size, offset); - ok &= getRawUInt32(data, *size, &offset, &(item->updateTS)); - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} -RsNxsGroupPublishKeyItem* RsNxsSerialiser::deserialNxsGroupPublishKeyItem(void *data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_GRP_PUBLISH_KEY_ITEM); - uint32_t offset = 8 ; - - RsNxsGroupPublishKeyItem* item = new RsNxsGroupPublishKeyItem(SERVICE_TYPE); - - ok &= item->grpId.deserialise(data, *size, offset); - ok &= item->private_key.GetTlv(data, *size, &offset) ; - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsGroupPublishKeyItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsGroupPublishKeyItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -RsNxsSessionKeyItem *RsNxsSerialiser::deserialNxsSessionKeyItem(void* data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_SESSION_KEY_ITEM); - uint32_t offset = 8 ; - - RsNxsSessionKeyItem* item = new RsNxsSessionKeyItem(SERVICE_TYPE); - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - - if(offset + EVP_MAX_IV_LENGTH >= *size) - { - std::cerr << __PRETTY_FUNCTION__ << ": not enough room for IV." << std::endl; - return NULL ; - } - memcpy(item->iv,&((uint8_t*)data)[offset],EVP_MAX_IV_LENGTH) ; - offset += EVP_MAX_IV_LENGTH ; - - uint32_t n ; - ok &= getRawUInt32(data, *size, &offset, &n) ; - - for(uint32_t i=0;ok && iencrypted_session_keys[gxs_id] = bdata ; - } - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsGroupPublishKeyItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsGroupPublishKeyItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} -RsNxsEncryptedDataItem *RsNxsSerialiser::deserialNxsEncryptedDataItem(void* data, uint32_t *size) -{ - bool ok = checkItemHeader(data,size,RS_PKT_SUBTYPE_NXS_ENCRYPTED_DATA_ITEM); - uint32_t offset = 8 ; - - RsNxsEncryptedDataItem* item = new RsNxsEncryptedDataItem(SERVICE_TYPE); - - ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); - item->encrypted_data.tlvtype = TLV_TYPE_BIN_ENCRYPTED ; - - ok &= item->encrypted_data.GetTlv(data,*size,&offset) ; - - if (offset != *size) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsGroupPublishKeyItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialNxsGroupPublishKeyItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - -/*** size functions ***/ - - -uint32_t RsNxsMsg::serial_size()const -{ - - uint32_t s = 8; //header size - - s += 4; // transaction number - s += 1; // pos - s += grpId.serial_size(); - s += msgId.serial_size(); - s += msg.TlvSize(); - s += meta.TlvSize(); - - return s; -} - -uint32_t RsNxsGrp::serial_size() const -{ - uint32_t s = 8; // header size - - s += 4; // transaction number - s += 1; // pos - s += grpId.serial_size(); - s += grp.TlvSize(); - s += meta.TlvSize(); - - return s; -} - -uint32_t RsNxsGroupPublishKeyItem::serial_size() const -{ - uint32_t s = 8; // header size - - s += grpId.serial_size() ; - s += private_key.TlvSize(); - - return s; -} -uint32_t RsNxsSyncGrpReqItem::serial_size() const -{ - uint32_t s = 8; // header size - - s += 4; // transaction number - s += 1; // flag - s += 4; // sync age - s += GetTlvStringSize(syncHash); - s += 4; // updateTS - - return s; -} -uint32_t RsNxsSyncGrpStatsItem::serial_size() const -{ - uint32_t s = 8; // header size - - s += 4; // request type - s += grpId.serial_size(); - s += 4; // number_of_posts - s += 4; // last_post_TS - - return s; -} - -uint32_t RsNxsSyncGrpItem::serial_size() const -{ - uint32_t s = 8; // header size - - s += 4; // transaction number - s += 4; // publishTs - s += 1; // flag - s += grpId.serial_size(); - s += authorId.serial_size(); - - return s; -} - - -uint32_t RsNxsSyncMsgReqItem::serial_size() const -{ - - uint32_t s = 8; - - s += 4; // transaction number - s += 1; // flag - s += 4; // age - s += grpId.serial_size(); - s += GetTlvStringSize(syncHash); - s += 4; // updateTS - - return s; -} - - -uint32_t RsNxsSyncMsgItem::serial_size() const -{ - uint32_t s = 8; // header size - - s += 4; // transaction number - s += 1; // flag - s += grpId.serial_size(); - s += msgId.serial_size(); - s += authorId.serial_size(); - - return s; -} - -uint32_t RsNxsTransacItem::serial_size() const -{ - uint32_t s = 8; // header size - - s += 4; // transaction number - s += 2; // flag - s += 4; // nMsgs - s += 4; // updateTS - - return s; -} -uint32_t RsNxsEncryptedDataItem::serial_size() const -{ - uint32_t s = 8; // header size - - s += 4; // transaction number - s += encrypted_data.TlvSize() ; - - return s; -} -uint32_t RsNxsSessionKeyItem::serial_size() const -{ - uint32_t s = 8; // header size - - s += 4; // transaction number - s += EVP_MAX_IV_LENGTH ; // iv - s += 4 ; // encrypted_session_keys.size() ; - - for(std::map::const_iterator it(encrypted_session_keys.begin());it!=encrypted_session_keys.end();++it) - s += it->first.serial_size() + it->second.TlvSize() ; - - return s; -} - - -std::ostream& RsNxsSyncGrpReqItem::print(std::ostream &out, uint16_t indent) -{ - - printRsItemBase(out, "RsNxsSyncGrp", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out , int_Indent); - out << "Hash: " << syncHash << std::endl; - printIndent(out , int_Indent); - out << "Sync Age: " << createdSince << std::endl; - printIndent(out , int_Indent); - out << "flag: " << (uint32_t) flag << std::endl; - printIndent(out , int_Indent); - out << "updateTS: " << updateTS << std::endl; - - printRsItemEnd(out ,"RsNxsSyncGrp", indent); - - return out; -} -std::ostream& RsNxsGroupPublishKeyItem::print(std::ostream &out, uint16_t indent) -{ - - printRsItemBase(out, "RsNxsGroupPublishKeyItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out , int_Indent); - out << "GroupId: " << grpId << std::endl; - printIndent(out , int_Indent); - out << "keyId: " << private_key.keyId << std::endl; - - printRsItemEnd(out ,"RsNxsGroupPublishKeyItem", indent); - - return out; -} - - -std::ostream& RsNxsSyncMsgReqItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsNxsSyncMsg", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out , int_Indent); - out << "GrpId: " << grpId << std::endl; - printIndent(out , int_Indent); - out << "createdSince: " << createdSinceTS << std::endl; - printIndent(out , int_Indent); - out << "syncHash: " << syncHash << std::endl; - printIndent(out , int_Indent); - out << "flag: " << (uint32_t) flag << std::endl; - printIndent(out , int_Indent); - out << "updateTS: " << updateTS << std::endl; - - printRsItemEnd(out, "RsNxsSyncMsg", indent); - return out; -} - -std::ostream& RsNxsSyncGrpItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsNxsSyncGrpItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out , int_Indent); - out << "flag: " << (uint32_t) flag << std::endl; - printIndent(out , int_Indent); - out << "grpId: " << grpId << std::endl; - printIndent(out , int_Indent); - out << "publishTs: " << publishTs << std::endl; - printIndent(out , int_Indent); - out << "authorId: " << authorId << std::endl; - - printRsItemEnd(out , "RsNxsSyncGrpItem", indent); - return out; -} - - - -std::ostream& RsNxsSyncMsgItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsNxsSyncMsgItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out , int_Indent); - out << "flag: " << (uint32_t) flag << std::endl; - printIndent(out , int_Indent); - out << "grpId: " << grpId << std::endl; - printIndent(out , int_Indent); - out << "msgId: " << msgId << std::endl; - printIndent(out , int_Indent); - out << "authorId: " << authorId << std::endl; - printIndent(out , int_Indent); - - printRsItemEnd(out ,"RsNxsSyncMsgItem", indent); - return out; -} - -RsNxsGrp* RsNxsGrp::clone() const { - RsNxsGrp* grp = new RsNxsGrp(PacketService()); - *grp = *this; - - if(this->metaData) - { - grp->metaData = new RsGxsGrpMetaData(); -// *(grp->metaData) = *(this->metaData); - } - - return grp; -} - -std::ostream& RsNxsGrp::print(std::ostream &out, uint16_t indent){ - - printRsItemBase(out, "RsNxsGrp", indent); - uint16_t int_Indent = indent + 2; - - out << "grpId: " << grpId << std::endl; - printIndent(out , int_Indent); - out << "grp: " << std::endl; - printIndent(out , int_Indent); - out << "pos: " << pos << std::endl; - grp.print(out, int_Indent); - out << "meta: " << std::endl; - meta.print(out, int_Indent); - - printRsItemEnd(out, "RsNxsGrp", indent); - return out; -} - -std::ostream& RsNxsMsg::print(std::ostream &out, uint16_t indent){ - - printRsItemBase(out, "RsNxsMsg", indent); - uint16_t int_Indent = indent + 2; - - out << "msgId: " << msgId << std::endl; - printIndent(out , int_Indent); - out << "grpId: " << grpId << std::endl; - printIndent(out , int_Indent); - out << "pos: " << pos << std::endl; - printIndent(out , int_Indent); - out << "msg: " << std::endl; - msg.print(out, indent); - out << "meta: " << std::endl; - meta.print(out, int_Indent); - - printRsItemEnd(out ,"RsNxsMsg", indent); - return out; -} - -std::ostream& RsNxsSyncGrpStatsItem::print(std::ostream &out, uint16_t indent){ - - printRsItemBase(out, "RsNxsSyncGrpStats", indent); - uint16_t int_Indent = indent + 2; - - out << "available posts: " << number_of_posts << std::endl; - printIndent(out , int_Indent); - out << "last update: " << last_post_TS << std::endl; - printIndent(out , int_Indent); - out << "group ID: " << grpId << std::endl; - printIndent(out , int_Indent); - out << "request type: " << request_type << std::endl; - printIndent(out , int_Indent); - - printRsItemEnd(out ,"RsNxsSyncGrpStats", indent); - return out; -} -std::ostream& RsNxsTransacItem::print(std::ostream &out, uint16_t indent){ - - printRsItemBase(out, "RsNxsTransac", indent); - uint16_t int_Indent = indent + 2; - - out << "transactFlag: " << transactFlag << std::endl; - printIndent(out , int_Indent); - out << "nItems: " << nItems << std::endl; - printIndent(out , int_Indent); - out << "timeout: " << timestamp << std::endl; - printIndent(out , int_Indent); - out << "updateTS: " << updateTS << std::endl; - printIndent(out , int_Indent); - out << "transactionNumber: " << transactionNumber << std::endl; - printIndent(out , int_Indent); - - printRsItemEnd(out ,"RsNxsTransac", indent); - return out; -} -std::ostream& RsNxsSessionKeyItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsNxsSessionKeyItem", indent); - - out << " iv: " << RsUtil::BinToHex((char*)iv,EVP_MAX_IV_LENGTH) << std::endl; - - out << " encrypted keys: " << std::endl; - - for(std::map::const_iterator it(encrypted_session_keys.begin());it!=encrypted_session_keys.end();++it) - out << " id=" << it->first << ": ekey=" << RsUtil::BinToHex((char*)it->second.bin_data,it->second.bin_len) << std::endl; - - printRsItemEnd(out ,"RsNxsSessionKeyItem", indent); - return out; -} -std::ostream& RsNxsEncryptedDataItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsNxsEncryptedDataItem", indent); - - out << " encrypted data: " << RsUtil::BinToHex((char*)encrypted_data.bin_data,std::min(50u,encrypted_data.bin_len)) ; - - if(encrypted_data.bin_len > 50u) - out << "..." ; - - out << std::endl; - - printRsItemEnd(out ,"RsNxsSessionKeyItem", indent); - return out; -} -#endif diff --git a/libretroshare/src/rsitems/rsrttitems.cc b/libretroshare/src/rsitems/rsrttitems.cc index c4c499f79..033975a3b 100644 --- a/libretroshare/src/rsitems/rsrttitems.cc +++ b/libretroshare/src/rsitems/rsrttitems.cc @@ -63,339 +63,5 @@ void RsRttPongItem::serial_process(RsGenericSerializer::SerializeJob j,RsGeneric RsTypeSerializer::serial_process(j,ctx,mPongTS,"mPongTS") ; } -#ifdef TO_REMOVE -RsRttPingItem::~RsRttPingItem() -{ - return; -} -void RsRttPingItem::clear() -{ - mSeqNo = 0; - mPingTS = 0; -} - -std::ostream& RsRttPingItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsRttPingItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "SeqNo: " << mSeqNo << std::endl; - - printIndent(out, int_Indent); - out << "PingTS: " << std::hex << mPingTS << std::dec << std::endl; - - printRsItemEnd(out, "RsRttPingItem", indent); - return out; -} - - - - - -RsRttPongItem::~RsRttPongItem() -{ - return; -} - -void RsRttPongItem::clear() -{ - mSeqNo = 0; - mPingTS = 0; - mPongTS = 0; -} - - -std::ostream& RsRttPongItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsRttPongItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "SeqNo: " << mSeqNo << std::endl; - - printIndent(out, int_Indent); - out << "PingTS: " << std::hex << mPingTS << std::dec << std::endl; - - printIndent(out, int_Indent); - out << "PongTS: " << std::hex << mPongTS << std::dec << std::endl; - - printRsItemEnd(out, "RsRttPongItem", indent); - return out; -} - - -/*************************************************************************/ - - -uint32_t RsRttSerialiser::sizeRttPingItem(RsRttPingItem */*item*/) -{ - uint32_t s = 8; /* header */ - s += 4; /* seqno */ - s += 8; /* pingTS */ - - return s; -} - -/* serialise the data to the buffer */ -bool RsRttSerialiser::serialiseRttPingItem(RsRttPingItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeRttPingItem(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsRttSerialiser::serialiseRttPingItem() Header: " << ok << std::endl; - std::cerr << "RsRttSerialiser::serialiseRttPingItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, item->mSeqNo); - ok &= setRawUInt64(data, tlvsize, &offset, item->mPingTS); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsRttSerialiser::serialiseRttPingItem() Size Error! " << std::endl; - } - - return ok; -} - -RsRttPingItem *RsRttSerialiser::deserialiseRttPingItem(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_RTT != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_RTT_PING != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsRttPingItem *item = new RsRttPingItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &(item->mSeqNo)); - ok &= getRawUInt64(data, rssize, &offset, &(item->mPingTS)); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ -/*************************************************************************/ - - -uint32_t RsRttSerialiser::sizeRttPongItem(RsRttPongItem */*item*/) -{ - uint32_t s = 8; /* header */ - s += 4; /* seqno */ - s += 8; /* pingTS */ - s += 8; /* pongTS */ - - return s; -} - -/* serialise the data to the buffer */ -bool RsRttSerialiser::serialiseRttPongItem(RsRttPongItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeRttPongItem(item); - uint32_t offset = 0; - - if (*pktsize < tlvsize) - return false; /* not enough space */ - - *pktsize = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - -#ifdef RSSERIAL_DEBUG - std::cerr << "RsRttSerialiser::serialiseRttPongItem() Header: " << ok << std::endl; - std::cerr << "RsRttSerialiser::serialiseRttPongItem() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, item->mSeqNo); - ok &= setRawUInt64(data, tlvsize, &offset, item->mPingTS); - ok &= setRawUInt64(data, tlvsize, &offset, item->mPongTS); - - if (offset != tlvsize) - { - ok = false; - std::cerr << "RsRttSerialiser::serialiseRttPongItem() Size Error! " << std::endl; - } - - return ok; -} - -RsRttPongItem *RsRttSerialiser::deserialiseRttPongItem(void *data, uint32_t *pktsize) -{ - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_RTT != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_RTT_PONG != getRsItemSubType(rstype))) - { - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - return NULL; /* not enough data */ - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsRttPongItem *item = new RsRttPongItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= getRawUInt32(data, rssize, &offset, &(item->mSeqNo)); - ok &= getRawUInt64(data, rssize, &offset, &(item->mPingTS)); - ok &= getRawUInt64(data, rssize, &offset, &(item->mPongTS)); - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -/*************************************************************************/ - -uint32_t RsRttSerialiser::size(RsItem *i) -{ - RsRttPingItem *ping; - RsRttPongItem *pong; - - if (NULL != (ping = dynamic_cast(i))) - { - return sizeRttPingItem(ping); - } - else if (NULL != (pong = dynamic_cast(i))) - { - return sizeRttPongItem(pong); - } - return 0; -} - -bool RsRttSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsMsgSerialiser::serialise()" << std::endl; -#endif - - RsRttPingItem *ping; - RsRttPongItem *pong; - - if (NULL != (ping = dynamic_cast(i))) - { - return serialiseRttPingItem(ping, data, pktsize); - } - else if (NULL != (pong = dynamic_cast(i))) - { - return serialiseRttPongItem(pong, data, pktsize); - } - return false; -} - -RsItem* RsRttSerialiser::deserialise(void *data, uint32_t *pktsize) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsRttSerialiser::deserialise()" << std::endl; -#endif - - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_TYPE_RTT != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - case RS_PKT_SUBTYPE_RTT_PING: - return deserialiseRttPingItem(data, pktsize); - break; - case RS_PKT_SUBTYPE_RTT_PONG: - return deserialiseRttPongItem(data, pktsize); - break; - default: - return NULL; - break; - } - - return NULL; -} - - -/*************************************************************************/ -#endif diff --git a/libretroshare/src/rsitems/rswikiitems.cc b/libretroshare/src/rsitems/rswikiitems.cc index ec42e14f0..96f9e2768 100644 --- a/libretroshare/src/rsitems/rswikiitems.cc +++ b/libretroshare/src/rsitems/rswikiitems.cc @@ -46,94 +46,6 @@ RsItem *RsGxsWikiSerialiser::create_item(uint16_t service, uint8_t item_sub_id) } } -#ifdef TO_REMOVE -uint32_t RsGxsWikiSerialiser::size(RsItem *item) -{ - RsGxsWikiCollectionItem* grp_item = NULL; - RsGxsWikiSnapshotItem* snap_item = NULL; - RsGxsWikiCommentItem* com_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return sizeGxsWikiCollectionItem(grp_item); - } - else if((snap_item = dynamic_cast(item)) != NULL) - { - return sizeGxsWikiSnapshotItem(snap_item); - } - else if((com_item = dynamic_cast(item)) != NULL) - { - return sizeGxsWikiCommentItem(com_item); - } - return 0; -} - -bool RsGxsWikiSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ - RsGxsWikiCollectionItem* grp_item = NULL; - RsGxsWikiSnapshotItem* snap_item = NULL; - RsGxsWikiCommentItem* com_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsWikiCollectionItem(grp_item, data, size); - } - else if((snap_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsWikiSnapshotItem(snap_item, data, size); - } - else if((com_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsWikiCommentItem(com_item, data, size); - } - return false; -} - -RsItem* RsGxsWikiSerialiser::deserialise(void* data, uint32_t* size) -{ - -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_WIKI != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_WIKI_COLLECTION_ITEM: - return deserialiseGxsWikiCollectionItem(data, size); - break; - case RS_PKT_SUBTYPE_WIKI_SNAPSHOT_ITEM: - return deserialiseGxsWikiSnapshotItem(data, size); - break; - case RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM: - return deserialiseGxsWikiCommentItem(data, size); - break; - default: -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialise(): unknown subtype"; - std::cerr << std::endl; -#endif - break; - } - return NULL; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -#endif - void RsGxsWikiCollectionItem::clear() { collection.mDescription.clear(); @@ -141,38 +53,6 @@ void RsGxsWikiCollectionItem::clear() collection.mHashTags.clear(); } -#ifdef TO_REMOVE -std::ostream& RsGxsWikiCollectionItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsWikiCollectionItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Description: " << collection.mDescription << std::endl; - printIndent(out, int_Indent); - out << "Category: " << collection.mCategory << std::endl; - printIndent(out, int_Indent); - out << "HashTags: " << collection.mHashTags << std::endl; - - printRsItemEnd(out ,"RsGxsWikiCollectionItem", indent); - return out; -} - - -uint32_t RsGxsWikiSerialiser::sizeGxsWikiCollectionItem(RsGxsWikiCollectionItem *item) -{ - - const RsWikiCollection& collection = item->collection; - uint32_t s = 8; // header - - s += GetTlvStringSize(collection.mDescription); - s += GetTlvStringSize(collection.mCategory); - s += GetTlvStringSize(collection.mHashTags); - - return s; -} -#endif - void RsGxsWikiCollectionItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR ,collection.mDescription,"collection.mDescription") ; @@ -180,448 +60,25 @@ void RsGxsWikiCollectionItem::serial_process(RsGenericSerializer::SerializeJob j RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_TAG,collection.mHashTags ,"collection.mHashTags") ; } -#ifdef TO_REMOVE -bool RsGxsWikiSerialiser::serialiseGxsWikiCollectionItem(RsGxsWikiCollectionItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiCollectionItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsWikiCollectionItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiCollectionItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsWikiCollectionItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DESCR, item->collection.mDescription); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_CATEGORY, item->collection.mCategory); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_TAG, item->collection.mHashTags); - - if(offset != tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiCollectionItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSID_DEBUG - if (!ok) - { - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiCollectionItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsWikiCollectionItem* RsGxsWikiSerialiser::deserialiseGxsWikiCollectionItem(void *data, uint32_t *size) -{ - -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCollectionItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_WIKI != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_WIKI_COLLECTION_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCollectionItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCollectionItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsWikiCollectionItem* item = new RsGxsWikiCollectionItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DESCR, item->collection.mDescription); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_CATEGORY, item->collection.mCategory); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_HASH_TAG, item->collection.mHashTags); - - if (offset != rssize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCollectionItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCollectionItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -#endif - void RsGxsWikiSnapshotItem::clear() { snapshot.mPage.clear(); snapshot.mHashTags.clear(); } -#ifdef TO_REMOVE -std::ostream& RsGxsWikiSnapshotItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsWikiSnapshotItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Page: " << snapshot.mPage << std::endl; - - printIndent(out, int_Indent); - out << "HashTags: " << snapshot.mHashTags << std::endl; - - printRsItemEnd(out ,"RsGxsWikiSnapshotItem", indent); - return out; -} - - -uint32_t RsGxsWikiSerialiser::sizeGxsWikiSnapshotItem(RsGxsWikiSnapshotItem *item) -{ - - const RsWikiSnapshot& snapshot = item->snapshot; - uint32_t s = 8; // header - - s += GetTlvStringSize(snapshot.mPage); - s += GetTlvStringSize(snapshot.mHashTags); - - return s; -} -#endif - void RsGxsWikiSnapshotItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_WIKI_PAGE,snapshot.mPage,"snapshot.mPage") ; RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_TAG ,snapshot.mPage,"snapshot.mHashTags") ; } -#ifdef TO_REMOVE -bool RsGxsWikiSerialiser::serialiseGxsWikiSnapshotItem(RsGxsWikiSnapshotItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiSnapshotItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsWikiSnapshotItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiSnapshotItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsWikiSnapshotItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_WIKI_PAGE, item->snapshot.mPage); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_TAG, item->snapshot.mHashTags); - - if(offset != tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiSnapshotItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSID_DEBUG - if (!ok) - { - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiSnapshotItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsWikiSnapshotItem* RsGxsWikiSerialiser::deserialiseGxsWikiSnapshotItem(void *data, uint32_t *size) -{ - -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiSnapshotItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_WIKI != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_WIKI_SNAPSHOT_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiSnapshotItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiSnapshotItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsWikiSnapshotItem* item = new RsGxsWikiSnapshotItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_WIKI_PAGE, item->snapshot.mPage); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_HASH_TAG, item->snapshot.mHashTags); - - if (offset != rssize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiSnapshotItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiSnapshotItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -#endif - void RsGxsWikiCommentItem::clear() { comment.mComment.clear(); } -#ifdef TO_REMOVE -std::ostream& RsGxsWikiCommentItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsWikiCommentItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Comment: " << comment.mComment << std::endl; - - printRsItemEnd(out ,"RsGxsWikiCommentItem", indent); - return out; -} - - -uint32_t RsGxsWikiSerialiser::sizeGxsWikiCommentItem(RsGxsWikiCommentItem *item) -{ - - const RsWikiComment& comment = item->comment; - uint32_t s = 8; // header - - s += GetTlvStringSize(comment.mComment); - - return s; -} -#endif - void RsGxsWikiCommentItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_COMMENT,comment.mComment,"comment.mComment") ; } -#ifdef TO_REMOVE -bool RsGxsWikiSerialiser::serialiseGxsWikiCommentItem(RsGxsWikiCommentItem *item, void *data, uint32_t *size) -{ - -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiCommentItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsWikiCommentItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiCommentItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsWikiCommentItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_COMMENT, item->comment.mComment); - - if(offset != tlvsize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiCommentItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef GXSID_DEBUG - if (!ok) - { - std::cerr << "RsGxsWikiSerialiser::serialiseGxsWikiCommentItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsWikiCommentItem* RsGxsWikiSerialiser::deserialiseGxsWikiCommentItem(void *data, uint32_t *size) -{ - -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCommentItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_WIKI != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM != getRsItemSubType(rstype))) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCommentItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCommentItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsWikiCommentItem* item = new RsGxsWikiCommentItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_COMMENT, item->comment.mComment); - - if (offset != rssize) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCommentItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef GXSID_DEBUG - std::cerr << "RsGxsWikiSerialiser::deserialiseGxsWikiCommentItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -#endif diff --git a/libretroshare/src/rsitems/rswireitems.cc b/libretroshare/src/rsitems/rswireitems.cc index 55a56a803..7a8008ff8 100644 --- a/libretroshare/src/rsitems/rswireitems.cc +++ b/libretroshare/src/rsitems/rswireitems.cc @@ -46,398 +46,19 @@ RsItem *RsGxsWireSerialiser::create_item(uint16_t service,uint8_t item_subtype) } } -#ifdef TO_REMOVE -uint32_t RsGxsWireSerialiser::size(RsItem *item) -{ - RsGxsWireGroupItem* grp_item = NULL; - RsGxsWirePulseItem* snap_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return sizeGxsWireGroupItem(grp_item); - } - else if((snap_item = dynamic_cast(item)) != NULL) - { - return sizeGxsWirePulseItem(snap_item); - } - return 0; -} - -bool RsGxsWireSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ - RsGxsWireGroupItem* grp_item = NULL; - RsGxsWirePulseItem* snap_item = NULL; - - if((grp_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsWireGroupItem(grp_item, data, size); - } - else if((snap_item = dynamic_cast(item)) != NULL) - { - return serialiseGxsWirePulseItem(snap_item, data, size); - } - return false; -} - -RsItem* RsGxsWireSerialiser::deserialise(void* data, uint32_t* size) -{ - -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialise()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_WIRE != getRsItemService(rstype))) - { - return NULL; /* wrong type */ - } - - switch(getRsItemSubType(rstype)) - { - - case RS_PKT_SUBTYPE_WIRE_GROUP_ITEM: - return deserialiseGxsWireGroupItem(data, size); - break; - case RS_PKT_SUBTYPE_WIRE_PULSE_ITEM: - return deserialiseGxsWirePulseItem(data, size); - break; - default: -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialise(): unknown subtype"; - std::cerr << std::endl; -#endif - break; - } - return NULL; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -#endif - void RsGxsWireGroupItem::clear() { group.mDescription.clear(); } -#ifdef TO_REMOVE -std::ostream& RsGxsWireGroupItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsWireGroupItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Description: " << group.mDescription << std::endl; - - printRsItemEnd(out ,"RsGxsWireGroupItem", indent); - return out; -} - - -uint32_t RsGxsWireSerialiser::sizeGxsWireGroupItem(RsGxsWireGroupItem *item) -{ - - const RsWireGroup& group = item->group; - uint32_t s = 8; // header - - s += GetTlvStringSize(group.mDescription); - - return s; -} - -#endif - void RsGxsWireGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR,group.mDescription,"group.mDescription") ; } -#ifdef TO_REMOVE -bool RsGxsWireSerialiser::serialiseGxsWireGroupItem(RsGxsWireGroupItem *item, void *data, uint32_t *size) -{ - -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::serialiseGxsWireGroupItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsWireGroupItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::serialiseGxsWireGroupItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsWireGroupItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DESCR, item->group.mDescription); - - if(offset != tlvsize) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::serialiseGxsWireGroupItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef WIRE_DEBUG - if (!ok) - { - std::cerr << "RsGxsWireSerialiser::serialiseGxsWireGroupItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsWireGroupItem* RsGxsWireSerialiser::deserialiseGxsWireGroupItem(void *data, uint32_t *size) -{ - -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWireGroupItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_WIRE != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_WIRE_GROUP_ITEM != getRsItemSubType(rstype))) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWireGroupItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWireGroupItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsWireGroupItem* item = new RsGxsWireGroupItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DESCR, item->group.mDescription); - - if (offset != rssize) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWireGroupItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWireGroupItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsWirePulseItem::clear() -{ - pulse.mPulseText.clear(); - pulse.mHashTags.clear(); -} - -std::ostream& RsGxsWirePulseItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsWirePulseItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "Page: " << pulse.mPulseText << std::endl; - - printIndent(out, int_Indent); - out << "HashTags: " << pulse.mHashTags << std::endl; - - printRsItemEnd(out ,"RsGxsWirePulseItem", indent); - return out; -} - - -uint32_t RsGxsWireSerialiser::sizeGxsWirePulseItem(RsGxsWirePulseItem *item) -{ - - const RsWirePulse& pulse = item->pulse; - uint32_t s = 8; // header - - s += GetTlvStringSize(pulse.mPulseText); - s += GetTlvStringSize(pulse.mHashTags); - - return s; -} - -#endif - void RsGxsWirePulseItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,pulse.mPulseText,"pulse.mPulseText") ; RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_HASH_TAG,pulse.mHashTags,"pulse.mHashTags") ; } -#ifdef TO_REMOVE -bool RsGxsWireSerialiser::serialiseGxsWirePulseItem(RsGxsWirePulseItem *item, void *data, uint32_t *size) -{ - -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::serialiseGxsWirePulseItem()" << std::endl; -#endif - - uint32_t tlvsize = sizeGxsWirePulseItem(item); - uint32_t offset = 0; - - if(*size < tlvsize) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::serialiseGxsWirePulseItem()" << std::endl; -#endif - return false; - } - - *size = tlvsize; - - bool ok = true; - - ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); - - /* skip the header */ - offset += 8; - - /* GxsWirePulseItem */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, item->pulse.mPulseText); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_TAG, item->pulse.mHashTags); - - if(offset != tlvsize) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::serialiseGxsWirePulseItem() FAIL Size Error! " << std::endl; -#endif - ok = false; - } - -#ifdef WIRE_DEBUG - if (!ok) - { - std::cerr << "RsGxsWireSerialiser::serialiseGxsWirePulseItem() NOK" << std::endl; - } -#endif - - return ok; - } - -RsGxsWirePulseItem* RsGxsWireSerialiser::deserialiseGxsWirePulseItem(void *data, uint32_t *size) -{ - -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWirePulseItem()" << std::endl; -#endif - /* get the type and size */ - uint32_t rstype = getRsItemId(data); - uint32_t rssize = getRsItemSize(data); - - uint32_t offset = 0; - - - if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || - (RS_SERVICE_GXS_TYPE_WIRE != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_WIRE_PULSE_ITEM != getRsItemSubType(rstype))) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWirePulseItem() FAIL wrong type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*size < rssize) /* check size */ - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWirePulseItem() FAIL wrong size" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *size = rssize; - - bool ok = true; - - RsGxsWirePulseItem* item = new RsGxsWirePulseItem(); - /* skip the header */ - offset += 8; - - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->pulse.mPulseText); - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_HASH_TAG, item->pulse.mHashTags); - - if (offset != rssize) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWirePulseItem() FAIL size mismatch" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) - { -#ifdef WIRE_DEBUG - std::cerr << "RsGxsWireSerialiser::deserialiseGxsWirePulseItem() NOK" << std::endl; -#endif - delete item; - return NULL; - } - - return item; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -#endif From 214aaa7c9b08c9a1106497c30ce2006ffa68b838 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 3 May 2017 22:20:58 +0200 Subject: [PATCH 93/94] added safety check for null chunks in TlvMemBlock_proxy deserialization --- .../src/serialiser/rstypeserializer.cc | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/libretroshare/src/serialiser/rstypeserializer.cc b/libretroshare/src/serialiser/rstypeserializer.cc index 661897b4b..f4cfc0d62 100644 --- a/libretroshare/src/serialiser/rstypeserializer.cc +++ b/libretroshare/src/serialiser/rstypeserializer.cc @@ -32,6 +32,7 @@ #include static const uint32_t MAX_SERIALIZED_ARRAY_SIZE = 500 ; +static const uint32_t MAX_SERIALIZED_CHUNK_SIZE = 10*1024*1024 ; // 10 MB. //=================================================================================================// // Integer types // @@ -231,9 +232,25 @@ template<> bool RsTypeSerializer::deserialize(const uint8_t data[],uint32_t size bool ok = deserialize(data,size,offset,r.second) ; + if(r.second == 0) + { + r.first = NULL ; + + if(!ok) + offset = saved_offset ; + + return ok ; + } + if(r.second > MAX_SERIALIZED_CHUNK_SIZE) + { + std::cerr << "(EE) RsTypeSerializer::deserialize(): data chunk has size larger than safety size (" << MAX_SERIALIZED_CHUNK_SIZE << "). Item will be dropped." << std::endl; + offset = saved_offset ; + return false ; + } + r.first = (uint8_t*)rs_malloc(r.second) ; - ok = ok && NULL != r.first; + ok = ok && (NULL != r.first); memcpy(r.first,&data[offset],r.second) ; offset += r.second ; From 4f4240d570ae6982e2ae475559ab0b026d31d0a9 Mon Sep 17 00:00:00 2001 From: csoler Date: Wed, 3 May 2017 22:43:16 +0200 Subject: [PATCH 94/94] fixed bug in history serializer --- libretroshare/src/rsitems/rshistoryitems.cc | 6 +++--- libretroshare/src/rsitems/rshistoryitems.h | 2 +- libretroshare/src/serialiser/rsserializer.h | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/libretroshare/src/rsitems/rshistoryitems.cc b/libretroshare/src/rsitems/rshistoryitems.cc index 23aa9e38f..a66299b51 100644 --- a/libretroshare/src/rsitems/rshistoryitems.cc +++ b/libretroshare/src/rsitems/rshistoryitems.cc @@ -51,12 +51,12 @@ void RsHistoryMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGene RsTypeSerializer::serial_process (j,ctx,TLV_TYPE_STR_MSG,message,"message") ; } -RsItem *RsHistorySerialiser::create_item(uint8_t serial_class,uint8_t serial_type) const +RsItem *RsHistorySerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const { - if(serial_class != RS_PKT_CLASS_CONFIG) + if(item_type != RS_PKT_TYPE_HISTORY_CONFIG) return NULL ; - if(serial_type == RS_PKT_SUBTYPE_DEFAULT) + if(item_subtype == RS_PKT_SUBTYPE_DEFAULT) return new RsHistoryMsgItem(); return NULL ; diff --git a/libretroshare/src/rsitems/rshistoryitems.h b/libretroshare/src/rsitems/rshistoryitems.h index 04d3e9ca7..802754e91 100644 --- a/libretroshare/src/rsitems/rshistoryitems.h +++ b/libretroshare/src/rsitems/rshistoryitems.h @@ -63,7 +63,7 @@ public: RsHistorySerialiser() : RsConfigSerializer(RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_HISTORY_CONFIG) {} virtual ~RsHistorySerialiser() {} - virtual RsItem *create_item(uint8_t service,uint8_t type) const ; + virtual RsItem *create_item(uint8_t item_type,uint8_t item_subtype) const ; }; /**************************************************************************/ diff --git a/libretroshare/src/serialiser/rsserializer.h b/libretroshare/src/serialiser/rsserializer.h index c9f1f6403..2cae93ab7 100644 --- a/libretroshare/src/serialiser/rsserializer.h +++ b/libretroshare/src/serialiser/rsserializer.h @@ -289,7 +289,7 @@ public: /*! create_item * should be overloaded to create the correct type of item depending on the data */ - virtual RsItem *create_item(uint8_t /* class */, uint8_t /* item_type */) const=0; + virtual RsItem *create_item(uint8_t /* item_type */, uint8_t /* item_sub_type */) const=0; RsItem *deserialise(void *data,uint32_t *size) ; };