diff --git a/libretroshare/src/chat/distantchat.cc b/libretroshare/src/chat/distantchat.cc index 70fb88d8c..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 @@ -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..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 = obj->signed_serial_size() ; + 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(!obj->serialise_signed_part(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 ; @@ -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,size,obj->signature,false,use_info,error_status)) { bool res = false ; @@ -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 ; @@ -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 = RsChatSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_SIGNATURE).size(dynamic_cast(&item)) ; RsTemporaryMemory memory(size) ; - if(!item.serialise_signed_part(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/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/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/chat/rschatitems.cc b/libretroshare/src/chat/rschatitems.cc index 90cf78fa6..2b7dd67d8 100644 --- a/libretroshare/src/chat/rschatitems.cc +++ b/libretroshare/src/chat/rschatitems.cc @@ -29,399 +29,44 @@ #include "serialiser/rsbaseserial.h" #include "serialiser/rstlvbase.h" +#include "serialiser/rstypeserializer.h" + #include "chat/rschatitems.h" //#define CHAT_DEBUG 1 -std::ostream& RsChatMsgItem::print(std::ostream &out, uint16_t indent) +static const uint32_t RS_CHAT_SERIALIZER_FLAGS_NO_SIGNATURE = 0x0001; + +RsItem *RsChatSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) const { - printRsItemBase(out, "RsChatMsgItem", indent); - uint16_t int_Indent = indent + 2; - printIndent(out, int_Indent); - out << "QblogMs " << chatFlags << std::endl; + if(service_id != RS_SERVICE_TYPE_CHAT) + return NULL ; - 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(j,ctx,signature,"signature") ; } -bool RsChatLobbyBouncingObject::serialise_to_memory(void *data,uint32_t tlvsize,uint32_t& offset,bool include_signature) +void RsChatLobbyMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - bool ok = true ; - - ok &= setRawUInt64(data, tlvsize, &offset, lobby_id); - ok &= setRawUInt64(data, tlvsize, &offset, msg_id); - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, nick); - - if(include_signature) - ok &= signature.SetTlv(data, tlvsize, &offset); - - return ok ; + RsChatMsgItem::serial_process(j,ctx) ; + RsTypeSerializer::serial_process(j,ctx,parent_msg_id,"parent_msg_id") ; + RsChatLobbyBouncingObject::serial_process(j,ctx) ; } -/* serialise the data to the buffer */ -bool RsChatLobbyMsgItem::serialise(void *data, uint32_t& pktsize) +void RsChatLobbyListRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t tlvsize = serial_size() ; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - bool ok = true; - ok &= RsChatMsgItem::serialise(data,pktsize) ; // first, serialize parent - - uint32_t offset = pktsize; - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); // correct header! - pktsize = tlvsize; - - ok &= setRawUInt64(data, tlvsize, &offset, parent_msg_id); - - // 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,true) ; - - /* add mandatory parts first */ - 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 ; -} -/* serialise the data to the buffer */ -bool RsChatLobbyMsgItem::serialise_signed_part(void *data, uint32_t& pktsize) -{ - uint32_t tlvsize = signed_serial_size() ; - - if (pktsize < tlvsize) - return false; /* not enough space */ - - bool ok = true; - ok &= RsChatMsgItem::serialise(data,pktsize) ; // first, serialize parent - - uint32_t offset = pktsize; - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); // correct header! - pktsize = tlvsize; - - //ok &= setRawUInt8(data, tlvsize, &offset, subpacket_id); // don't serialise sub-part id. - ok &= setRawUInt64(data, tlvsize, &offset, parent_msg_id); - - // 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) ; - - /* add mandatory parts first */ - 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 ; + // nothing to do. This is an empty item. } - -bool RsChatLobbyListRequestItem::serialise(void *data, uint32_t& pktsize) +template<> void RsTypeSerializer::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,VisibleChatLobbyInfo& info,const std::string& name) { - uint32_t tlvsize = serial_size() ; - bool ok = true ; - ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize); // correct header! + RsTypeSerializer::serial_process(j,ctx,info.id,"info.id") ; - if (pktsize < tlvsize) - return false; /* not enough space */ - - pktsize = tlvsize ; - return ok ; -} -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, info.count,"info.count") ; + RsTypeSerializer::serial_process (j,ctx, info.flags,"info.flags") ; } -bool RsChatLobbyUnsubscribeItem::serialise(void *data, uint32_t& pktsize) +void RsChatLobbyListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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 ; -} -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 ; + RsTypeSerializer::serial_process(j,ctx,lobbies,"lobbies") ; } -bool RsChatLobbyInviteItem::serialise(void *data, uint32_t& pktsize) +void RsChatLobbyEventItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t tlvsize = serial_size() ; + 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") ; - 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 ; + RsChatLobbyBouncingObject::serial_process(j,ctx) ; +} +void RsChatLobbyUnsubscribeItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,lobby_id,"lobby_id") ; } -bool RsPrivateChatMsgConfigItem::serialise(void *data, uint32_t& pktsize) +void RsChatLobbyConnectChallengeItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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; -} -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; + RsTypeSerializer::serial_process(j,ctx,challenge_code,"challenge_code") ; } -bool RsChatAvatarItem::serialise(void *data, uint32_t& pktsize) +void RsChatLobbyInviteItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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; -} -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; + 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") ; } -RsChatMsgItem::RsChatMsgItem(void *data,uint32_t /*size*/,uint8_t subtype) - : RsChatItem(subtype) +void RsPrivateChatMsgConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; + uint32_t x=0 ; -#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 ; + 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") ; } -RsChatLobbyMsgItem::RsChatLobbyMsgItem(void *data,uint32_t /*size*/) - : RsChatMsgItem(data,0,RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_MSG) +void RsChatStatusItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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;i(j,ctx,lobby_Id,"lobby_Id") ; + RsTypeSerializer::serial_process(j,ctx,flags,"flags") ; } /* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */ @@ -1229,53 +195,4 @@ void RsPrivateChatMsgConfigItem::get(RsChatMsgItem *ci) ci->recvTime = recvTime; } -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 ; -} - diff --git a/libretroshare/src/chat/rschatitems.h b/libretroshare/src/chat/rschatitems.h index 13b42c18f..ddc0a2b86 100644 --- a/libretroshare/src/chat/rschatitems.h +++ b/libretroshare/src/chat/rschatitems.h @@ -27,8 +27,11 @@ #include "openssl/bn.h" #include "retroshare/rstypes.h" +#include "serialiser/rsserializer.h" #include "serialiser/rstlvkeys.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" +#include "rsitems/rsitem.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" @@ -78,7 +81,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 @@ -90,11 +93,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) { return out; } // 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 +108,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + virtual void clear() {} uint32_t chatFlags; uint32_t sendTime; @@ -137,21 +138,15 @@ 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. - - virtual uint32_t signed_serial_size() =0; - virtual bool serialise_signed_part(void *data,uint32_t& size) = 0; 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. - uint32_t serialized_size(bool include_signature) ; - bool serialise_to_memory(void *data,uint32_t tlvsize,uint32_t& offset,bool include_signature) ; - bool deserialise_from_memory(void *data,uint32_t rssize,uint32_t& offset) ; + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + virtual uint32_t PacketId() const= 0; }; class RsChatLobbyMsgItem: public RsChatMsgItem, public RsChatLobbyBouncingObject @@ -159,55 +154,44 @@ 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 - - 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 ? + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); ChatLobbyMsgId parent_msg_id ; // Used for threaded chat. + +protected: + virtual uint32_t PacketId() const { return RsChatMsgItem::PacketId() ; } }; class RsChatLobbyEventItem: public RsChatItem, public RsChatLobbyBouncingObject { - public: - RsChatLobbyEventItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_EVENT) {} - RsChatLobbyEventItem(void *data,uint32_t size) ; // deserialization /// TODO!!! +public: + RsChatLobbyEventItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_SIGNED_EVENT) {} - 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() ; + virtual ~RsChatLobbyEventItem() {} + virtual RsChatLobbyBouncingObject *duplicate() const { return new RsChatLobbyEventItem(*this) ; } + // + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 - // 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 { 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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; struct VisibleChatLobbyInfo @@ -223,13 +207,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); std::vector lobbies ; }; @@ -238,48 +218,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 ~RsChatLobbyInviteItem() {} - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 }; /*! @@ -290,14 +260,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 + 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); @@ -311,43 +278,20 @@ 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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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. @@ -356,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t flags ; std::string status_string; @@ -374,58 +315,20 @@ 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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t image_size ; // size of data in bytes 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 +class RsChatSerialiser: public RsServiceSerializer { public: - RsChatDHPublicKeyItem() :RsChatItem(RS_PKT_SUBTYPE_DISTANT_CHAT_DH_PUBLIC_KEY) {setPriorityLevel(QOS_PRIORITY_RS_CHAT_ITEM) ;} - RsChatDHPublicKeyItem(void *data,uint32_t size) ; // deserialization + RsChatSerialiser(SerializationFlags flags = SERIALIZATION_FLAG_NONE) + :RsServiceSerializer(RS_SERVICE_TYPE_CHAT,RsGenericSerializer::FORMAT_BINARY,flags) {} - 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 - - // 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 RsSerialType -{ - public: - RsChatSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, 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) const ; }; 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/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.cc b/libretroshare/src/file_sharing/rsfilelistitems.cc index 800f2f3d8..7d91549d4 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.cc +++ b/libretroshare/src/file_sharing/rsfilelistitems.cc @@ -24,342 +24,41 @@ */ #include "serialiser/rsbaseserial.h" +#include "serialiser/rstypeserializer.h" + #include "file_sharing/rsfilelistitems.h" -RsItem* RsFileListsSerialiser::deserialise(void *data, uint32_t *size) +void RsFileListsSyncRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { -#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; - - } - } + 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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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") ; } -uint32_t RsFileListsSerialiser::size(RsItem *item) +RsItem *RsFileListsSerialiser::create_item(uint16_t service,uint8_t type) const { - RsFileListsItem *flst_item = dynamic_cast(item) ; + if(service != RS_SERVICE_TYPE_FILE_DATABASE) + return NULL ; - 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) + switch(type) { - std::cerr << "RsFileListsSerialiser::serialiseNxsSynMsgItem() NOK" << std::endl; + 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 ; } -#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; -} - -void RsFileListsSyncRequestItem::clear() -{ } void RsFileListsSyncResponseItem::clear() { directory_content_data.TlvClear(); } -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; -} diff --git a/libretroshare/src/file_sharing/rsfilelistitems.h b/libretroshare/src/file_sharing/rsfilelistitems.h index 8c1d466e1..51e40b9c3 100644 --- a/libretroshare/src/file_sharing/rsfilelistitems.h +++ b/libretroshare/src/file_sharing/rsfilelistitems.h @@ -27,13 +27,16 @@ #include #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvitem.h" #include "serialiser/rstlvkeys.h" #include "gxs/rsgxsdata.h" +#include "serialiser/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 +57,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 +77,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 +94,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsFileHash entry_hash ; // hash of the directory to sync RsFileHash checksum ; // checksum of the bindary data, for checking @@ -112,24 +106,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 RsServiceSerializer { public: - RsFileListsSerialiser() : RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_FILE_DATABASE) {} + RsFileListsSerialiser() : RsServiceSerializer(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 ; }; 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 e63a5f1a8..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() */ @@ -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/ft/ftserver.cc b/libretroshare/src/ft/ftserver.cc index caab409e8..15a44f34f 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 @@ -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(),RsServiceSerializer(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) const { - 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..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 +class ftServer: public p3Service, public RsFiles, public ftDataSend, public RsTurtleClientService, public RsServiceSerializer { public: @@ -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 RsTurtleGenericTunnelItem *deserialiseItem(void *data,uint32_t size) const ; + virtual RsItem *create_item(uint16_t service,uint8_t item_type) const ; + 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/ft/ftturtlefiletransferitem.cc b/libretroshare/src/ft/ftturtlefiletransferitem.cc index b4ce91623..44722af4b 100644 --- a/libretroshare/src/ft/ftturtlefiletransferitem.cc +++ b/libretroshare/src/ft/ftturtlefiletransferitem.cc @@ -27,539 +27,48 @@ #include #include -#include +#include #include -uint32_t RsTurtleFileRequestItem::serial_size() const +#include + +void RsTurtleFileMapRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t s = 0 ; - - s += 8 ; // header - s += 4 ; // tunnel id - s += 8 ; // file offset - s += 4 ; // chunk size - - return s ; + RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,direction,"direction") ; } -uint32_t RsTurtleFileDataItem::serial_size() const +void RsTurtleFileMapItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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 ; + 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(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(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") ; } -uint32_t RsTurtleFileMapRequestItem::serial_size() const +void RsTurtleFileRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t s = 0 ; + 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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tunnel_id,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,chunk_offset,"chunk_offset") ; - s += 8 ; // header - s += 4 ; // tunnel id - s += 4 ; // direction + RsTypeSerializer::TlvMemBlock_proxy prox(chunk_data,chunk_size) ; - 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 ; -} -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,chunk_start ,"chunk_start") ; + RsTypeSerializer::serial_process(j,ctx,chunk_size ,"chunk_size") ; + RsTypeSerializer::serial_process(j,ctx,total_size ,"total_size") ; - if(tlvsize < rssize) - { - std::cerr << __PRETTY_FUNCTION__ << ": wrong encoding of item size. Serialisation error!" << std::endl; - return NULL ; - } - - RsGRouterTransactionChunkItem *item = new RsGRouterTransactionChunkItem() ; + // Hack for backward compatibility (the chunk size is not directly next to the chunk data) - /* 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; -} -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; -} -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) + if(j == RsGenericSerializer::DESERIALIZE) { - 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) + 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; - delete item; - return NULL ; + ctx.mOk = false ; + return ; } - - if( NULL == (item->data_bytes = (uint8_t*)rs_malloc(item->data_size))) + if( NULL == (chunk_data = (uint8_t*)rs_malloc(chunk_size))) { - delete item; - return NULL ; + ctx.mOk = false ; + return ; } - memcpy(item->data_bytes,&((uint8_t*)data)[offset],item->data_size) ; - offset += item->data_size ; + memcpy(chunk_data,&((uint8_t*)ctx.mData)[ctx.mOffset],chunk_size) ; + ctx.mOffset += chunk_size ; } - else - item->data_bytes = NULL ; + else if(j== RsGenericSerializer::SERIALIZE) + { + memcpy(&((uint8_t*)ctx.mData)[ctx.mOffset],chunk_data,chunk_size) ; + ctx.mOffset += chunk_size ; + } + 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; - ok &= item->signature.GetTlv(data, pktsize, &offset) ; +} +void RsGRouterTransactionAcknItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,propagation_id,"propagation_id") ; +} - 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) +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") ; + 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 == 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) { - item->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(item->duplication_factor > GROUTER_MAX_DUPLICATION_FACTOR) + if(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 ; + std::cerr << "(WW) correcting GRouter item duplication factor of " << duplication_factor << ". This is very unexpected." << std::endl; + 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; + } } -RsGRouterSignedReceiptItem *RsGRouterSerialiser::deserialise_RsGRouterSignedReceiptItem(void *data, uint32_t pktsize) const +void RsGRouterSignedReceiptItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; + 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") ; - RsGRouterSignedReceiptItem *item = new RsGRouterSignedReceiptItem() ; + if(ctx.mFlags & RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE) + return ; - 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; + RsTypeSerializer::serial_process(j,ctx,signature,"signature") ; } -RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *data, uint32_t pktsize) const +void RsGRouterRoutingInfoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(data); - bool ok = true ; + 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") ; - RsGRouterRoutingInfoItem *item = new RsGRouterRoutingInfoItem() ; + RsTypeSerializer::serial_process (j,ctx,last_tunnel_request_TS,"last_tunnel_request_TS") ; + RsTypeSerializer::serial_process(j,ctx,sending_attempts,"sending_attempts") ; - RsPeerId peer_id ; - ok &= peer_id.deserialise(data, pktsize, offset) ; - item->PeerId(peer_id) ; + 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") ; - 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); + RsTypeSerializer::serial_process(j,ctx,incoming_routes,"incoming_routes") ; - ok &= getRawTimeT(data, pktsize, &offset, item->last_tunnel_request_TS); - ok &= getRawUInt32(data, pktsize, &offset, &item->sending_attempts); + // 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. - 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) + if(j == RsGenericSerializer::DESERIALIZE) { - std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; - delete item; - return NULL ; - } + data_item = new RsGRouterGenericDataItem() ; - return item; + 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 == RsGenericSerializer::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(receipt_item,ctx.mData,&remaining_size); + ctx.mOffset += RsGRouterSerialiser().size(receipt_item) ; + } + } + else if(j == RsGenericSerializer::PRINT) + { + std::cerr << " [Serialized data] " << std::endl; + + if(receipt_item != NULL) + std::cerr << " [Receipt item ]" << std::endl; + } + else if(j == RsGenericSerializer::SIZE_ESTIMATE) + { + ctx.mOffset += RsGRouterSerialiser().size(data_item) ; + + if(receipt_item != NULL) + ctx.mOffset += RsGRouterSerialiser().size(receipt_item) ; + } } -RsGRouterMatrixFriendListItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(void *data, uint32_t pktsize) const + +void RsGRouterMatrixFriendListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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; + RsTypeSerializer::serial_process(j,ctx,reverse_friend_indices,"reverse_friend_indices") ; } -RsGRouterMatrixTrackItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixTrackItem(void *data, uint32_t pktsize) const +void RsGRouterMatrixTrackItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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; + 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") ; } -RsGRouterMatrixCluesItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesItem(void *data, uint32_t pktsize) const + +void RsGRouterMatrixCluesItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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; + RsTypeSerializer::serial_process(j,ctx,destination_key,"destination_key") ; + RsTypeSerializer::serial_process(j,ctx,clues,"clues") ; } + +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") ; + RsTypeSerializer::serial_process (j,ctx,s.time_stamp,name+":time_stamp") ; +} + RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const { RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem ; @@ -393,506 +247,4 @@ RsGRouterSignedReceiptItem *RsGRouterSignedReceiptItem::duplicate() const return item ; } -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 ; -} diff --git a/libretroshare/src/grouter/grouteritems.h b/libretroshare/src/grouter/grouteritems.h index a0c3dd9e7..505f35361 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" @@ -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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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,RsGenericSerializer::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 5f2b6e7d0..d77903df8 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" @@ -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) ; @@ -2184,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/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 c56b47c12..303d411b8 100644 --- a/libretroshare/src/gxs/rsgds.h +++ b/libretroshare/src/gxs/rsgds.h @@ -32,8 +32,8 @@ #include "inttypes.h" -#include "serialiser/rsgxsitems.h" -#include "serialiser/rsnxsitems.h" +#include "rsitems/rsgxsitems.h" +#include "rsitems/rsnxsitems.h" #include "gxs/rsgxsdata.h" #include "rsgxs.h" #include "util/contentvalue.h" diff --git a/libretroshare/src/gxs/rsgenexchange.cc b/libretroshare/src/gxs/rsgenexchange.cc index 571489212..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) @@ -1375,7 +1376,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/gxs/rsgenexchange.h b/libretroshare/src/gxs/rsgenexchange.h index ec9c0d3f0..43891a80d 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/rsgxsdata.h b/libretroshare/src/gxs/rsgxsdata.h index 2b2e9f14d..76924167c 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" struct RsGroupMetaData; struct RsMsgMetaData; diff --git a/libretroshare/src/gxs/rsgxsnetservice.cc b/libretroshare/src/gxs/rsgxsnetservice.cc index 7258ae775..789a77441 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.cc +++ b/libretroshare/src/gxs/rsgxsnetservice.cc @@ -3517,10 +3517,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 ; @@ -3547,7 +3547,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/gxs/rsgxsnetservice.h b/libretroshare/src/gxs/rsgxsnetservice.h index fba79ebc9..fe1dbef0d 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.h +++ b/libretroshare/src/gxs/rsgxsnetservice.h @@ -33,8 +33,8 @@ #include "rsgds.h" #include "rsnxsobserver.h" #include "pqi/p3linkmgr.h" -#include "serialiser/rsnxsitems.h" -#include "serialiser/rsgxsupdateitems.h" +#include "rsitems/rsnxsitems.h" +#include "rsitems/rsgxsupdateitems.h" #include "rsgxsnetutils.h" #include "pqi/p3cfgmgr.h" #include "rsgixs.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/gxstunnel/p3gxstunnel.cc b/libretroshare/src/gxstunnel/p3gxstunnel.cc index 871a5cd49..69bc091f4 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..8e488c190 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 "serialiser/rstypeserializer.h" #include "util/rsprint.h" #include "util/rsmemory.h" @@ -35,459 +36,89 @@ //#define GXS_TUNNEL_ITEM_DEBUG 1 -std::ostream& RsGxsTunnelDHPublicKeyItem::print(std::ostream &out, uint16_t indent) +RsItem *RsGxsTunnelSerialiser::create_item(uint16_t service,uint8_t item_subtype) const { - printRsItemBase(out, "RsGxsTunnelDHPublicKeyItem", indent); - uint16_t int_Indent = indent + 2; + if(service != RS_SERVICE_TYPE_GXS_TUNNEL) + return NULL ; - 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; + 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 ; + } } -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; -} - -/*************************************************************************/ - RsGxsTunnelDHPublicKeyItem::~RsGxsTunnelDHPublicKeyItem() { BN_free(public_key) ; } -/*************************************************************************/ - -RsItem *RsGxsTunnelSerialiser::deserialise(void *data, uint32_t *pktsize) +void RsGxsTunnelDHPublicKeyItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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 ; - } + 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") ; } -/*************************************************************************/ - -uint32_t RsGxsTunnelDHPublicKeyItem::serial_size() +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, BIGNUM * const & member) { - 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 + uint32_t s = BN_num_bytes(member) ; - return s ; -} + if(size < offset + 4 + s) + return false ; -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 + bool ok = true ; + ok &= setRawUInt32(data, size, &offset, s); - 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 ; -} -/*************************************************************************/ - -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]) ; + BN_bn2bin(member,&((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 ; + return ok; } - -bool RsGxsTunnelStatusItem::serialise(void *data, uint32_t& pktsize) +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, BIGNUM *& member) { - 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; -} - -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); + uint32_t s=0 ; bool ok = true ; + ok &= getRawUInt32(data, size, &offset, &s); - RsGxsTunnelDHPublicKeyItem *item = new RsGxsTunnelDHPublicKeyItem() ; + if(s > size || size - s < offset) + return false ; - 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) ; + member = 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 ; + return ok; } - -RsGxsTunnelDataItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelDataItem(void *dat,uint32_t size) +template<> uint32_t RsTypeSerializer::serial_size(BIGNUM * const & member) { - 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 ; + return 4 + BN_num_bytes(member) ; } - -RsGxsTunnelDataAckItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelDataAckItem(void *dat,uint32_t /* size */) +template<> void RsTypeSerializer::print_data(const std::string& name,BIGNUM * const & /* member */) { - 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 ; + std::cerr << "[BIGNUM] : " << name << std::endl; } -RsGxsTunnelStatusItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelStatusItem(void *dat, uint32_t size) +void RsGxsTunnelStatusItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t offset = 8; // skip the header - uint32_t rssize = getRsItemSize(dat); - bool ok = true ; + RsTypeSerializer::serial_process(j,ctx,status,"status") ; +} - if(rssize > size) - { - std::cerr << "RsGxsTunnelStatusItem::() Size error while deserializing." << std::endl ; - return NULL ; - } +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") ; - 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 ; + 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") ; } @@ -505,3 +136,4 @@ RsGxsTunnelStatusItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelStatusItem( + diff --git a/libretroshare/src/gxstunnel/rsgxstunnelitems.h b/libretroshare/src/gxstunnel/rsgxstunnelitems.h index c23a8b9a1..1bec905c8 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 "serialiser/rsserviceids.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" @@ -57,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 }; /*! @@ -78,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? @@ -100,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 ; }; @@ -117,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 }; @@ -136,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 // @@ -154,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/libretroshare.pro b/libretroshare/src/libretroshare.pro index 03c50d954..46daa85e8 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 { @@ -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 @@ -457,17 +457,17 @@ HEADERS += grouter/groutercache.h \ grouter/groutertypes.h \ grouter/rsgrouterclient.h -HEADERS += serialiser/itempriorities.h \ +HEADERS += rsitems/rsitem.h \ + rsitems/itempriorities.h \ serialiser/rsbaseserial.h \ - serialiser/rsfiletransferitems.h \ - serialiser/rsserviceserialiser.h \ - serialiser/rsconfigitems.h \ - serialiser/rshistoryitems.h \ - serialiser/rsmsgitems.h \ + rsitems/rsfiletransferitems.h \ + rsitems/rsconfigitems.h \ + rsitems/rshistoryitems.h \ + rsitems/rsmsgitems.h \ serialiser/rsserial.h \ - serialiser/rsserviceids.h \ + rsitems/rsserviceids.h \ serialiser/rsserviceitems.h \ - serialiser/rsstatusitems.h \ + rsitems/rsstatusitems.h \ serialiser/rstlvaddrs.h \ serialiser/rstlvbase.h \ serialiser/rstlvitem.h \ @@ -484,14 +484,14 @@ HEADERS += serialiser/itempriorities.h \ serialiser/rstlvlist.h \ serialiser/rstlvmaps.h \ serialiser/rstlvbanlist.h \ - serialiser/rsbanlistitems.h \ - serialiser/rsbwctrlitems.h \ - serialiser/rsdiscovery2items.h \ - serialiser/rsheartbeatitems.h \ - serialiser/rsrttitems.h \ - serialiser/rsgxsrecognitems.h \ - serialiser/rsgxsupdateitems.h \ - serialiser/rsserviceinfoitems.h \ + rsitems/rsbanlistitems.h \ + rsitems/rsbwctrlitems.h \ + rsitems/rsdiscovery2items.h \ + rsitems/rsheartbeatitems.h \ + rsitems/rsrttitems.h \ + rsitems/rsgxsrecognitems.h \ + rsitems/rsgxsupdateitems.h \ + rsitems/rsserviceinfoitems.h \ HEADERS += services/p3msgservice.h \ services/p3service.h \ @@ -609,17 +609,14 @@ 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 \ - serialiser/rsfiletransferitems.cc \ - serialiser/rsserviceserialiser.cc \ - serialiser/rsconfigitems.cc \ - serialiser/rshistoryitems.cc \ - serialiser/rsmsgitems.cc \ + rsitems/rsfiletransferitems.cc \ + rsitems/rsconfigitems.cc \ + rsitems/rshistoryitems.cc \ + rsitems/rsmsgitems.cc \ serialiser/rsserial.cc \ - serialiser/rsstatusitems.cc \ serialiser/rstlvaddrs.cc \ serialiser/rstlvbase.cc \ serialiser/rstlvitem.cc \ @@ -632,14 +629,13 @@ SOURCES += serialiser/rsbaseserial.cc \ serialiser/rstlvkeyvalue.cc \ serialiser/rstlvgenericparam.cc \ serialiser/rstlvbanlist.cc \ - serialiser/rsbanlistitems.cc \ - serialiser/rsbwctrlitems.cc \ - serialiser/rsdiscovery2items.cc \ - serialiser/rsheartbeatitems.cc \ - serialiser/rsrttitems.cc \ - serialiser/rsgxsrecognitems.cc \ - serialiser/rsgxsupdateitems.cc \ - serialiser/rsserviceinfoitems.cc \ + rsitems/rsbanlistitems.cc \ + rsitems/rsbwctrlitems.cc \ + rsitems/rsdiscovery2items.cc \ + rsitems/rsrttitems.cc \ + rsitems/rsgxsrecognitems.cc \ + rsitems/rsgxsupdateitems.cc \ + rsitems/rsserviceinfoitems.cc \ SOURCES += services/p3msgservice.cc \ services/p3service.cc \ @@ -726,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 \ @@ -739,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 \ @@ -752,12 +748,12 @@ HEADERS += serialiser/rsnxsitems.h \ gxs/rsgxsrequesttypes.h -SOURCES += serialiser/rsnxsitems.cc \ +SOURCES += rsitems/rsnxsitems.cc \ gxs/rsdataservice.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 \ @@ -776,85 +772,92 @@ HEADERS += gxstunnel/p3gxstunnel.h \ SOURCES += gxstunnel/p3gxstunnel.cc \ gxstunnel/rsgxstunnelitems.cc +# new serialization code +HEADERS += serialiser/rsserializer.h \ + serialiser/rstypeserializer.h + +SOURCES += serialiser/rsserializer.cc \ + serialiser/rstypeserializer.cc + # Identity Service HEADERS += retroshare/rsidentity.h \ gxs/rsgixs.h \ services/p3idservice.h \ - serialiser/rsgxsiditems.h \ + rsitems/rsgxsiditems.h \ services/p3gxsreputation.h \ - serialiser/rsgxsreputationitems.h \ + rsitems/rsgxsreputationitems.h \ SOURCES += services/p3idservice.cc \ - serialiser/rsgxsiditems.cc \ + rsitems/rsgxsiditems.cc \ services/p3gxsreputation.cc \ - serialiser/rsgxsreputationitems.cc \ + rsitems/rsgxsreputationitems.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 \ 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 \ services/p3gxschannels.h \ services/p3gxscommon.h \ - serialiser/rsgxscommentitems.h \ - serialiser/rsgxschannelitems.h \ + rsitems/rsgxscommentitems.h \ + rsitems/rsgxschannelitems.h \ SOURCES += services/p3gxschannels.cc \ services/p3gxscommon.cc \ - serialiser/rsgxscommentitems.cc \ - serialiser/rsgxschannelitems.cc \ + rsitems/rsgxscommentitems.cc \ + rsitems/rsgxschannelitems.cc \ 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 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 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/plugins/pluginmanager.cc b/libretroshare/src/plugins/pluginmanager.cc index 259004300..fa38394a5 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/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 d190a903b..72a2640ec 100644 --- a/libretroshare/src/pqi/p3historymgr.cc +++ b/libretroshare/src/pqi/p3historymgr.cc @@ -26,11 +26,11 @@ #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 "serialiser/rsmsgitems.h" +#include "rsitems/rsmsgitems.h" #include "rsserver/p3face.h" #include "util/rsstring.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 97e738a40..cad91f30b 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. @@ -2295,43 +2295,6 @@ bool p3PeerMgrIMPL::loadList(std::list& load) continue; } - 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; - } - RsNodeGroupItem *gitem2 = dynamic_cast(*it) ; if (gitem2) diff --git a/libretroshare/src/pqi/p3servicecontrol.cc b/libretroshare/src/pqi/p3servicecontrol.cc index 799093d29..3942232c4 100644 --- a/libretroshare/src/pqi/p3servicecontrol.cc +++ b/libretroshare/src/pqi/p3servicecontrol.cc @@ -26,10 +26,10 @@ #include #include "p3servicecontrol.h" -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -#include "serialiser/rsbaseserial.h" -#include "serialiser/rsnxsitems.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "serialiser/rstypeserializer.h" +#include "rsitems/rsnxsitems.h" #include "pqi/p3cfgmgr.h" #include "pqi/pqiservice.h" @@ -43,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/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/pqipersongrp.cc b/libretroshare/src/pqi/pqipersongrp.cc index a30eb2738..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 @@ -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/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/pqisslpersongrp.cc b/libretroshare/src/pqi/pqisslpersongrp.cc index a1173fd93..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" @@ -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/pqi/pqistore.cc b/libretroshare/src/pqi/pqistore.cc index ca6d23820..7372529b1 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 @@ -309,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 ; @@ -521,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) + if(blocklength < blen || blocklength > 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) { 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/retroshare/rsgxsifacetypes.h b/libretroshare/src/retroshare/rsgxsifacetypes.h index 1bc17b5e0..fd477fc9f 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/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/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/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/rsitems/rsbanlistitems.cc b/libretroshare/src/rsitems/rsbanlistitems.cc new file mode 100644 index 000000000..358d20961 --- /dev/null +++ b/libretroshare/src/rsitems/rsbanlistitems.cc @@ -0,0 +1,71 @@ +/* + * libretroshare/src/serialiser: rsbanlist.cc + * + * RetroShare Serialiser. + * + * Copyright 2011 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 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 "serialiser/rsbaseserial.h" +#include "rsitems/rsbanlistitems.h" + +#include "serialiser/rstypeserializer.h" + +/*** +#define RSSERIAL_DEBUG 1 +***/ + +#include + +/*************************************************************************/ + +void RsBanListItem::clear() +{ + peerList.TlvClear(); +} + +void RsBanListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,peerList,"peerList") ; +} + +void RsBanListConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + 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") ; +} +RsItem *RsBanListSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id) const +{ + if(service_id != RS_SERVICE_TYPE_BANLIST) + return NULL ; + + switch(item_sub_id) + { + 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 ; + } +} + + diff --git a/libretroshare/src/serialiser/rsbanlistitems.h b/libretroshare/src/rsitems/rsbanlistitems.h similarity index 56% rename from libretroshare/src/serialiser/rsbanlistitems.h rename to libretroshare/src/rsitems/rsbanlistitems.h index 372f71a5d..e5660e55c 100644 --- a/libretroshare/src/serialiser/rsbanlistitems.h +++ b/libretroshare/src/rsitems/rsbanlistitems.h @@ -28,13 +28,15 @@ #include -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" #include "serialiser/rstlvbanlist.h" +#include "serialiser/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 +44,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); RsTlvBanList peerList; }; @@ -64,40 +64,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 RsServiceSerializer { 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() :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.cc b/libretroshare/src/rsitems/rsbwctrlitems.cc new file mode 100644 index 000000000..bfa172b45 --- /dev/null +++ b/libretroshare/src/rsitems/rsbwctrlitems.cc @@ -0,0 +1,61 @@ +/* + * libretroshare/src/serialiser: rsbwctrlitems.cc + * + * RetroShare Serialiser. + * + * Copyright 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 "serialiser/rsbaseserial.h" +#include "rsitems/rsbwctrlitems.h" + +/*** +#define RSSERIAL_DEBUG 1 +***/ + +#include + +/*************************************************************************/ + +RsItem *RsBwCtrlSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const +{ + 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() +{ + allowedBw = 0; +} + +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/serialiser/rsbwctrlitems.h b/libretroshare/src/rsitems/rsbwctrlitems.h similarity index 56% rename from libretroshare/src/serialiser/rsbwctrlitems.h rename to libretroshare/src/rsitems/rsbwctrlitems.h index c1679c9c9..71ec641e1 100644 --- a/libretroshare/src/serialiser/rsbwctrlitems.h +++ b/libretroshare/src/rsitems/rsbwctrlitems.h @@ -28,9 +28,12 @@ #include -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -#include "serialiser/rstlvbase.h" +#include "rsitems/rsitem.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" + +#include "serialiser/rsserializer.h" +#include "serialiser/rstypeserializer.h" #define RS_PKT_SUBTYPE_BWCTRL_ALLOWED_ITEM 0x01 @@ -38,44 +41,29 @@ 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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + uint32_t allowedBw; // Units are bytes/sec => 4Gb/s; }; -class RsBwCtrlSerialiser: public RsSerialType +class RsBwCtrlSerialiser: public RsServiceSerializer { - 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() :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/rsconfigitems.cc b/libretroshare/src/rsitems/rsconfigitems.cc new file mode 100644 index 000000000..15a8dd624 --- /dev/null +++ b/libretroshare/src/rsitems/rsconfigitems.cc @@ -0,0 +1,268 @@ + +/* + * libretroshare/src/serialiser: rsconfigitems.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Robert Fernie, Chris Parker. + * + * 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 "serialiser/rsbaseserial.h" +#include "rsitems/rsconfigitems.h" +#include "retroshare/rspeers.h" // Needed for RsGroupInfo. + +#include "serialiser/rstypeserializer.h" +/*** + * #define RSSERIAL_DEBUG 1 + * #define RSSERIAL_ERROR_DEBUG 1 + ***/ + +#define RSSERIAL_ERROR_DEBUG 1 + +#include + + +/*************************************************************************/ + +RsItem *RsFileConfigSerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const +{ + if(item_type != RS_PKT_TYPE_FILE_CONFIG) + return NULL ; + + switch(item_subtype) + { + 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; + +} + +void RsFileTransfer::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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") ; +} + +void RsFileConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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") ; +} + +RsItem *RsGeneralConfigSerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const +{ + if(item_type != RS_PKT_TYPE_GENERAL_CONFIG) + return NULL ; + + switch(item_subtype) + { + case RS_PKT_SUBTYPE_KEY_VALUE: return new RsConfigKeyValueSet(); + default: + return NULL ; + } +} + +void RsConfigKeyValueSet::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,tlvkvs,"tlvkvs") ; +} + +RsItem *RsPeerConfigSerialiser::create_item(uint8_t item_type,uint8_t item_subtype) const +{ + if(item_type != RS_PKT_TYPE_PEER_CONFIG) + return NULL ; + + switch(item_subtype) + { + 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; +} +void RsPeerNetItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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") ; +} + +void RsPeerBandwidthLimitsItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,peers,"peers") ; +} + +void RsPeerStunItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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; +} + +void RsNodeGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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") ; +} + +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 == RsGenericSerializer::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 + +#include "rsitems/rsitem.h" + +#include "retroshare/rstypes.h" +#include "serialiser/rsserial.h" + +#include "serialiser/rstlvidset.h" +#include "serialiser/rstlvfileitem.h" +#include "serialiser/rstlvkeyvalue.h" +#include "serialiser/rstlvaddrs.h" + +#include "serialiser/rsserializer.h" + +class RsGroupInfo; + +const uint8_t RS_PKT_TYPE_GENERAL_CONFIG = 0x01; +const uint8_t RS_PKT_TYPE_PEER_CONFIG = 0x02; +const uint8_t RS_PKT_TYPE_CACHE_CONFIG = 0x03; +const uint8_t RS_PKT_TYPE_FILE_CONFIG = 0x04; +const uint8_t RS_PKT_TYPE_PLUGIN_CONFIG = 0x05; +const uint8_t RS_PKT_TYPE_HISTORY_CONFIG = 0x06; + + /* GENERAL CONFIG SUBTYPES */ +const uint8_t RS_PKT_SUBTYPE_KEY_VALUE = 0x01; + + /* PEER CONFIG SUBTYPES */ +const uint8_t RS_PKT_SUBTYPE_PEER_STUN = 0x02; +const uint8_t RS_PKT_SUBTYPE_PEER_NET = 0x03; +const uint8_t RS_PKT_SUBTYPE_PEER_GROUP_deprecated = 0x04; +const uint8_t RS_PKT_SUBTYPE_PEER_PERMISSIONS = 0x05; +const uint8_t RS_PKT_SUBTYPE_PEER_BANDLIMITS = 0x06; +const uint8_t RS_PKT_SUBTYPE_NODE_GROUP = 0x07; + + /* FILE CONFIG SUBTYPES */ +const uint8_t RS_PKT_SUBTYPE_FILE_TRANSFER = 0x01; +const uint8_t RS_PKT_SUBTYPE_FILE_ITEM_deprecated = 0x02; +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) {} + + virtual ~RsPeerNetItem(){} + virtual void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + /* networking information */ + RsPeerId peerId; /* 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 */ + + RsTlvIpAddress localAddrV4; /* Mandatory */ + RsTlvIpAddress extAddrV4; /* Mandatory */ + RsTlvIpAddress localAddrV6; /* Mandatory */ + RsTlvIpAddress extAddrV6; /* Mandatory */ + + std::string dyndns; + + RsTlvIpAddrSet localAddrList; + RsTlvIpAddrSet extAddrList; + + // for proxy connection. + std::string domain_addr; + uint16_t domain_port; +}; + +// This item should be merged with the next item, but that is not backward compatible. +class RsPeerServicePermissionItem : public RsItem +{ + public: + RsPeerServicePermissionItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_PEER_PERMISSIONS) {} + virtual ~RsPeerServicePermissionItem() {} + + virtual void clear() + { + pgp_ids.clear() ; + service_flags.clear() ; + } + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + + /* Mandatory */ + std::vector pgp_ids ; + std::vector service_flags ; +}; +class RsPeerBandwidthLimitsItem : public RsItem +{ + public: + RsPeerBandwidthLimitsItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_PEER_BANDLIMITS) {} + virtual ~RsPeerBandwidthLimitsItem() {} + + virtual void clear() + { + peers.clear() ; + } + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + /* Mandatory */ + std::map peers ; +}; + +class RsNodeGroupItem: public RsItem +{ +public: + RsNodeGroupItem(): RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_NODE_GROUP){} + virtual ~RsNodeGroupItem() {} + + virtual void clear() { pgpList.TlvClear();} + + explicit RsNodeGroupItem(const RsGroupInfo&) ; + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + // /* set data from RsGroupInfo to RsPeerGroupItem */ + // void set(RsGroupInfo &groupInfo); + // /* get data from RsGroupInfo to RsPeerGroupItem */ + // void get(RsGroupInfo &groupInfo); + + /* Mandatory */ + RsNodeGroupId id; + std::string name; + uint32_t flag; + + RsTlvPgpIdSet pgpList; +}; + +class RsPeerStunItem: public RsItem +{ +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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsTlvPeerIdSet stunList; /* Mandatory */ +}; + +class RsPeerConfigSerialiser: public RsConfigSerializer +{ + public: + RsPeerConfigSerialiser() :RsConfigSerializer(RS_PKT_CLASS_CONFIG,RS_PKT_TYPE_PEER_CONFIG) {} + + virtual ~RsPeerConfigSerialiser(){} + + virtual RsItem *create_item(uint8_t item_type, uint8_t item_subtype) const ; +}; + +/**************************************************************************/ + +class RsFileTransfer: public RsItem +{ + public: + RsFileTransfer() :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_FILE_CONFIG, RS_PKT_SUBTYPE_FILE_TRANSFER) + { + state = 0; + in = 0; + transferred = 0; + crate = 0; + trate = 0; + lrate = 0; + ltransfer = 0; + flags = 0; + chunk_strategy = 0; + } + virtual ~RsFileTransfer(){} + virtual void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsTlvFileItem file; + RsTlvPeerIdSet allPeerIds; + + RsPeerId cPeerId; + + uint16_t state; + uint16_t in; + + uint64_t transferred; + uint32_t crate; + uint32_t trate; + + uint32_t lrate; + uint32_t ltransfer; + + // chunk information + uint32_t flags ; + uint32_t chunk_strategy ; // strategy flags for chunks + CompressedChunkMap compressed_chunk_map ; // chunk availability (bitwise) +}; + +/**************************************************************************/ + +const uint32_t RS_FILE_CONFIG_CLEANUP_DELETE = 0x0001; + +class RsFileConfigItem: public RsItem +{ +public: + RsFileConfigItem() :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_FILE_CONFIG, RS_PKT_SUBTYPE_FILE_ITEM) {} + virtual ~RsFileConfigItem() {} + virtual void clear() { parent_groups.TlvClear(); } + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsTlvFileItem file; + uint32_t flags; + RsTlvNodeGroupIdSet parent_groups ; +}; +/**************************************************************************/ + +class RsFileConfigSerialiser: public RsConfigSerializer +{ + public: + RsFileConfigSerialiser() :RsConfigSerializer(RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_FILE_CONFIG) { } + virtual ~RsFileConfigSerialiser() {} + + virtual RsItem *create_item(uint8_t item_type, uint8_t item_subtype) const ; +}; + +/**************************************************************************/ + +/* Config items that are used generally */ + +class RsConfigKeyValueSet: public RsItem +{ +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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsTlvKeyValueSet tlvkvs; +}; + + +class RsGeneralConfigSerialiser: public RsConfigSerializer +{ + public: + RsGeneralConfigSerialiser() :RsConfigSerializer(RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_GENERAL_CONFIG) {} + + virtual RsItem *create_item(uint8_t item_type, uint8_t item_subtype) const ; +}; + +#endif /* RS_CONFIG_ITEMS_SERIALISER_H */ diff --git a/libretroshare/src/rsitems/rsdiscovery2items.cc b/libretroshare/src/rsitems/rsdiscovery2items.cc new file mode 100644 index 000000000..0d1d3a493 --- /dev/null +++ b/libretroshare/src/rsitems/rsdiscovery2items.cc @@ -0,0 +1,293 @@ + +/* + * libretroshare/src/serialiser: rsdiscitems.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 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 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/rsdiscovery2items.h" +#include "serialiser/rsbaseserial.h" + +#include "serialiser/rstypeserializer.h" + +#if 0 + +#include "rsitems/rsserviceids.h" + +#include "serialiser/rstlvbase.h" +#include "serialiser/rstlvtypes.h" +#endif + +/*** + * #define RSSERIAL_DEBUG 1 + * #define RSSERIAL_ERROR_DEBUG 1 + ***/ + +#define RSSERIAL_ERROR_DEBUG 1 + +#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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 == RsGenericSerializer::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 + { + 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"); + } +} + +/*************************************************************************/ +#if 0 + +RsDiscServicesItem::~RsDiscServicesItem() +{ + return; +} + +void RsDiscServicesItem::clear() +{ + version.clear(); + mServiceIdMap.TlvClear(); +} + +std::ostream &RsDiscServicesItem::print(std::ostream &out, uint16_t indent) +{ + printRsItemBase(out, "RsDiscServicesItem", indent); + uint16_t int_Indent = indent + 2; + + printIndent(out, int_Indent); + out << "version: " << version << std::endl; + mServiceIdMap.print(out, int_Indent); + + printRsItemEnd(out, "RsDiscServicesItem", indent); + return out; +} + + +uint32_t RsDiscSerialiser::sizeServices(RsDiscServicesItem *item) +{ + uint32_t s = 8; /* header */ + s += GetTlvStringSize(item->version); /* version */ + s += item->mServiceIdMap.TlvSize(); + return s; +} + +/* serialise the data to the buffer */ +bool RsDiscSerialiser::serialiseServices(RsDiscServicesItem *item, void *data, uint32_t *pktsize) +{ + uint32_t tlvsize = sizeServices(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::serialiseServices() Header: " << ok << std::endl; + std::cerr << "RsDiscSerialiser::serialiseServices() Size: " << tlvsize << std::endl; +#endif + + /* skip the header */ + offset += 8; + + /* add mandatory parts first */ + ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VERSION, item->version); + ok &= item->mServiceIdMap.SetTlv(data, tlvsize, &offset); + + if (offset != tlvsize) { + ok = false; +#ifdef RSSERIAL_ERROR_DEBUG + std::cerr << "RsDiscSerialiser::serialiseServices() Size Error! " << std::endl; +#endif + } + + return ok; +} + +RsDiscServicesItem *RsDiscSerialiser::deserialiseServices(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::deserialiseServices() Wrong Type" << std::endl; +#endif + return NULL; /* wrong type */ + } + + if (*pktsize < rssize) /* check size */ + { +#ifdef RSSERIAL_ERROR_DEBUG + std::cerr << "RsDiscSerialiser::deserialiseServices() Not Enough Space" << std::endl; +#endif + return NULL; /* not enough data */ + } + + /* set the packet length */ + *pktsize = rssize; + + bool ok = true; + + /* ready to load */ + RsDiscServicesItem *item = new RsDiscServicesItem(); + item->clear(); + + /* skip the header */ + offset += 8; + + /* get mandatory parts first */ + ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VERSION, item->version); + ok &= item->mServiceIdMap.GetTlv(data, rssize, &offset); + + if (offset != rssize) { +#ifdef RSSERIAL_ERROR_DEBUG + std::cerr << "RsDiscSerialiser::deserialiseServices() offset != rssize" << std::endl; +#endif + /* error */ + delete item; + return NULL; + } + + if (!ok) { +#ifdef RSSERIAL_ERROR_DEBUG + std::cerr << "RsDiscSerialiser::deserialiseServices() ok = false" << std::endl; +#endif + delete item; + return NULL; + } + + return item; +} + +#endif diff --git a/libretroshare/src/serialiser/rsdiscovery2items.h b/libretroshare/src/rsitems/rsdiscovery2items.h similarity index 58% rename from libretroshare/src/serialiser/rsdiscovery2items.h rename to libretroshare/src/rsitems/rsdiscovery2items.h index dad0d0fb5..012ebe1b5 100644 --- a/libretroshare/src/serialiser/rsdiscovery2items.h +++ b/libretroshare/src/rsitems/rsdiscovery2items.h @@ -31,7 +31,11 @@ #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" #include "serialiser/rstlvaddrs.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.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; @@ -52,18 +56,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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); uint32_t mode; RsTlvPgpIdSet pgpIdSet; @@ -73,18 +77,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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */); RsPgpId pgpId; std::string pgpCert; @@ -93,30 +97,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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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 +130,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 +168,14 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent = 0); #endif -class RsDiscSerialiser: public RsSerialType +class RsDiscSerialiser: public RsServiceSerializer { public: - RsDiscSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DISC) - { return; } + RsDiscSerialiser() :RsServiceSerializer(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 ; }; diff --git a/libretroshare/src/rsitems/rsfiletransferitems.cc b/libretroshare/src/rsitems/rsfiletransferitems.cc new file mode 100644 index 000000000..7579c9560 --- /dev/null +++ b/libretroshare/src/rsitems/rsfiletransferitems.cc @@ -0,0 +1,156 @@ + +/* + * libretroshare/src/serialiser: rsbaseitems.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 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 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 "serialiser/rsbaseserial.h" +#include "serialiser/rstlvbase.h" +#include "rsitems/rsfiletransferitems.h" + +#include "serialiser/rstypeserializer.h" + +/*** + * #define RSSERIAL_DEBUG 1 + * #define DEBUG_TRANSFERS 1 +***/ + + +#ifdef DEBUG_TRANSFERS + #include "util/rsprint.h" +#endif + +#include + +void RsFileTransferDataRequestItem::clear() +{ + file.TlvClear(); + fileoffset = 0; + chunksize = 0; +} +void RsFileTransferDataItem::clear() +{ + fd.TlvClear(); +} + +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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,fd,"fd") ; +} + +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(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(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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + 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") ; +} + +//===================================================================================================// +// CompressedChunkMap // +//===================================================================================================// + +template<> uint32_t RsTypeSerializer::serial_size(const CompressedChunkMap& s) +{ + return 4 + 4*s._map.size() ; +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset,const CompressedChunkMap& s) +{ + bool ok = true ; + + ok &= setRawUInt32(data, size, &offset, s._map.size()); + + for(uint32_t i=0;i bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size,uint32_t& offset,CompressedChunkMap& s) +{ + uint32_t S =0; + bool ok = getRawUInt32(data, size, &offset, &S); + + if(ok) + { + s._map.resize(S) ; + + for(uint32_t i=0;i void RsTypeSerializer::print_data(const std::string& n, const CompressedChunkMap& s) +{ + std::cerr << " [Compressed chunk map] " << n << " : length=" << s._map.size() << std::endl; +} + +//===================================================================================================// +// Serializer // +//===================================================================================================// + +RsItem *RsFileTransferSerialiser::create_item(uint16_t service_type,uint8_t item_type) const +{ + if(service_type != RS_SERVICE_TYPE_FILE_TRANSFER) + return NULL ; + + 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/rsitems/rsfiletransferitems.h similarity index 59% rename from libretroshare/src/serialiser/rsfiletransferitems.h rename to libretroshare/src/rsitems/rsfiletransferitems.h index fa989861d..85f6d5eab 100644 --- a/libretroshare/src/serialiser/rsfiletransferitems.h +++ b/libretroshare/src/rsitems/rsfiletransferitems.h @@ -29,10 +29,12 @@ #include "retroshare/rstypes.h" #include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" #include "serialiser/rstlvfileitem.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" +#include "serialiser/rsserializer.h" const uint8_t RS_PKT_SUBTYPE_FT_DATA_REQUEST = 0x01; const uint8_t RS_PKT_SUBTYPE_FT_DATA = 0x02; @@ -53,20 +55,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 +70,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // Private data part. // @@ -103,11 +92,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); - virtual std::ostream& print(std::ostream &out, uint16_t indent = 0); + virtual void clear(); // Private data part. // @@ -122,10 +109,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); // Private data part. // @@ -142,11 +128,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + virtual void clear() {} // Private data part. // @@ -163,11 +147,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + virtual void clear() {} // Private data part. // @@ -183,11 +165,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + virtual void clear() {} // Private data part. // @@ -196,65 +176,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 RsServiceSerializer { public: - RsFileTransferSerialiser(): RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_FILE_TRANSFER) {} + RsFileTransferSerialiser(): RsServiceSerializer(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) const ; }; diff --git a/libretroshare/src/rsitems/rsgxschannelitems.cc b/libretroshare/src/rsitems/rsgxschannelitems.cc new file mode 100644 index 000000000..a8cc067b1 --- /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 "serialiser/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 58% rename from libretroshare/src/serialiser/rsgxschannelitems.h rename to libretroshare/src/rsitems/rsgxschannelitems.h index f7386b93d..b0fc67987 100644 --- a/libretroshare/src/serialiser/rsgxschannelitems.h +++ b/libretroshare/src/rsitems/rsgxschannelitems.h @@ -28,33 +28,32 @@ #include -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" +#include "rsitems/rsserviceids.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 "serialiser/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); @@ -68,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: @@ -89,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 */ diff --git a/libretroshare/src/rsitems/rsgxscircleitems.cc b/libretroshare/src/rsitems/rsgxscircleitems.cc new file mode 100644 index 000000000..40ae6cf5f --- /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 "serialiser/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 58% rename from libretroshare/src/serialiser/rsgxscircleitems.h rename to libretroshare/src/rsitems/rsgxscircleitems.h index 4ae4e7109..5734b34cd 100644 --- a/libretroshare/src/serialiser/rsgxscircleitems.h +++ b/libretroshare/src/rsitems/rsgxscircleitems.h @@ -28,13 +28,13 @@ #include -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" +#include "rsitems/rsserviceids.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; @@ -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/rsitems/rsgxscommentitems.cc b/libretroshare/src/rsitems/rsgxscommentitems.cc new file mode 100644 index 000000000..8c175a1bd --- /dev/null +++ b/libretroshare/src/rsitems/rsgxscommentitems.cc @@ -0,0 +1,59 @@ +/* + * libretroshare/src/serialiser: rsgxscommentitems.cc + * + * RetroShare C++ Interface. + * + * Copyright 2012-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". + * + */ + +#include + +#include "rsgxscommentitems.h" +#include "serialiser/rstlvbase.h" +#include "serialiser/rsbaseserial.h" +#include "serialiser/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 ; + } +} + + +void RsGxsCommentItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,1,mMsg.mComment,"mMsg.mComment") ; +} + +void RsGxsVoteItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mMsg.mVoteType,"mMsg.mVoteType") ; +} + diff --git a/libretroshare/src/serialiser/rsgxscommentitems.h b/libretroshare/src/rsitems/rsgxscommentitems.h similarity index 53% rename from libretroshare/src/serialiser/rsgxscommentitems.h rename to libretroshare/src/rsitems/rsgxscommentitems.h index 6f5d1bddd..ec5d6ae2c 100644 --- a/libretroshare/src/serialiser/rsgxscommentitems.h +++ b/libretroshare/src/rsitems/rsgxscommentitems.h @@ -28,9 +28,7 @@ #include -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" +#include "rsitems/rsserviceids.h" #include "rsgxsitems.h" @@ -43,11 +41,11 @@ 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; }; @@ -57,40 +55,23 @@ 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() {} + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; }; #endif /* RS_GXS_COMMENT_ITEMS_H */ diff --git a/libretroshare/src/rsitems/rsgxsforumitems.cc b/libretroshare/src/rsitems/rsgxsforumitems.cc new file mode 100644 index 000000000..fb5b8f632 --- /dev/null +++ b/libretroshare/src/rsitems/rsgxsforumitems.cc @@ -0,0 +1,67 @@ +/* + * libretroshare/src/serialiser: rsgxsforumitems.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 "rsgxsforumitems.h" + +#include "serialiser/rstypeserializer.h" + +//#define GXSFORUM_DEBUG 1 + +RsItem *RsGxsForumSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const +{ + if(service_id != RS_SERVICE_GXS_TYPE_FORUMS) + return NULL ; + + 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 ; + } +} +void RsGxsForumGroupItem::clear() +{ + mGroup.mDescription.clear(); +} + +void RsGxsForumGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR,mGroup.mDescription,"mGroup.Description"); +} +void RsGxsForumMsgItem::clear() +{ + mMsg.mMsg.clear(); +} + +void RsGxsForumMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_MSG,mMsg.mMsg,"mGroup.Description"); +} + + + diff --git a/libretroshare/src/rsitems/rsgxsforumitems.h b/libretroshare/src/rsitems/rsgxsforumitems.h new file mode 100644 index 000000000..5ce8a84ee --- /dev/null +++ b/libretroshare/src/rsitems/rsgxsforumitems.h @@ -0,0 +1,77 @@ +/* + * libretroshare/src/serialiser: rsgxsforumitems.h + * + * 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 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". + * + */ + +#ifndef RS_GXS_FORUM_ITEMS_H +#define RS_GXS_FORUM_ITEMS_H + +#include + +#include "rsitems/rsserviceids.h" +#include "rsitems/rsgxsitems.h" + +#include "serialiser/rsserializer.h" + +#include "retroshare/rsgxsforums.h" + +const uint8_t RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM = 0x02; +const uint8_t RS_PKT_SUBTYPE_GXSFORUM_MESSAGE_ITEM = 0x03; + +class RsGxsForumGroupItem : public RsGxsGrpItem +{ + +public: + + 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; +}; + +class RsGxsForumMsgItem : public RsGxsMsgItem +{ +public: + + 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 RsServiceSerializer +{ +public: + RsGxsForumSerialiser() :RsServiceSerializer(RS_SERVICE_GXS_TYPE_FORUMS) {} + virtual ~RsGxsForumSerialiser() {} + + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; +}; + +#endif /* RS_GXS_FORUM_ITEMS_H */ diff --git a/libretroshare/src/rsitems/rsgxsiditems.cc b/libretroshare/src/rsitems/rsgxsiditems.cc new file mode 100644 index 000000000..1a4eac4e8 --- /dev/null +++ b/libretroshare/src/rsitems/rsgxsiditems.cc @@ -0,0 +1,125 @@ +/* + * libretroshare/src/serialiser: rsgxsiditems.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 "rsgxsiditems.h" +#include "serialiser/rstlvbase.h" +#include "serialiser/rsbaseserial.h" +#include "serialiser/rstlvstring.h" +#include "util/rsstring.h" + +#include "serialiser/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(); +} +void RsGxsIdLocalInfoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mTimeStamps,"mTimeStamps") ; + RsTypeSerializer::serial_process(j,ctx,mContacts,"mContacts") ; +} + +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") ; + + // image is optional + + if(j == RsGenericSerializer::DESERIALIZE && ctx.mOffset == ctx.mSize) + return ; + + RsTypeSerializer::serial_process(j,ctx,mImage,"mImage") ; +} + +bool RsGxsIdGroupItem::fromGxsIdGroup(RsGxsIdGroup &group, bool moveImage) +{ + clear(); + meta = group.mMeta; + mPgpIdHash = group.mPgpIdHash; + mPgpIdSign = group.mPgpIdSign; + mRecognTags = group.mRecognTags; + + 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 RsGxsIdGroupItem::toGxsIdGroup(RsGxsIdGroup &group, bool moveImage) +{ + group.mMeta = meta; + group.mPgpIdHash = mPgpIdHash; + group.mPgpIdSign = mPgpIdSign; + group.mRecognTags = mRecognTags; + + 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 ; +} + diff --git a/libretroshare/src/serialiser/rsgxsiditems.h b/libretroshare/src/rsitems/rsgxsiditems.h similarity index 66% rename from libretroshare/src/serialiser/rsgxsiditems.h rename to libretroshare/src/rsitems/rsgxsiditems.h index 483916055..19802a9a1 100644 --- a/libretroshare/src/serialiser/rsgxsiditems.h +++ b/libretroshare/src/rsitems/rsgxsiditems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" #include "rsgxsitems.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/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 88% rename from libretroshare/src/serialiser/rsgxsitems.h rename to libretroshare/src/rsitems/rsgxsitems.h index 4e46a39a4..fa461a0e8 100644 --- a/libretroshare/src/serialiser/rsgxsitems.h +++ b/libretroshare/src/rsitems/rsgxsitems.h @@ -26,16 +26,14 @@ * */ -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" -//#include "serialiser/rstlvkeys.h" +#include "rsitems/rsitem.h" +#include "rsitems/rsserviceids.h" + #include "retroshare/rsgxsifacetypes.h" std::ostream &operator<<(std::ostream &out, const RsGroupMetaData &meta); std::ostream &operator<<(std::ostream &out, const RsMsgMetaData &meta); - class RsGxsGrpItem : public RsItem { @@ -45,7 +43,6 @@ public: : RsItem(RS_PKT_VERSION_SERVICE, service, subtype) { return; } virtual ~RsGxsGrpItem(){} - RsGroupMetaData meta; }; diff --git a/libretroshare/src/rsitems/rsgxsrecognitems.cc b/libretroshare/src/rsitems/rsgxsrecognitems.cc new file mode 100644 index 000000000..bb6a40ca8 --- /dev/null +++ b/libretroshare/src/rsitems/rsgxsrecognitems.cc @@ -0,0 +1,118 @@ +/* + * libretroshare/src/serialiser: rsgxsrecogitems.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". + * + */ + +#include "rsitems/rsgxsrecognitems.h" +#include "serialiser/rstypeserializer.h" + +/*** +#define RSSERIAL_DEBUG 1 +***/ + +#include + +/*************************************************************************/ + +RsItem *RsGxsRecognSerialiser::create_item(uint16_t service, uint8_t item_sub_id) const +{ + 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() +{ + issued_at = 0; + period = 0; + tag_class = 0; + tag_type = 0; + + identity.clear(); + nickname.clear(); + comment.clear(); + + sign.TlvClear(); + +} +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") ; +} + +void RsGxsRecognTagItem::clear() +{ + valid_from = 0; + valid_to = 0; + + tag_class = 0; + tag_type = 0; + + identity.clear(); + nickname.clear(); + + sign.TlvClear(); +} + +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") ; +} + +void RsGxsRecognSignerItem::clear() +{ + signing_classes.TlvClear(); + key.TlvClear(); + sign.TlvClear(); +} + +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") ; +} + + + diff --git a/libretroshare/src/serialiser/rsgxsrecognitems.h b/libretroshare/src/rsitems/rsgxsrecognitems.h similarity index 50% rename from libretroshare/src/serialiser/rsgxsrecognitems.h rename to libretroshare/src/rsitems/rsgxsrecognitems.h index a8aad7c31..e072477ce 100644 --- a/libretroshare/src/serialiser/rsgxsrecognitems.h +++ b/libretroshare/src/rsitems/rsgxsrecognitems.h @@ -28,8 +28,10 @@ #include -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" +#include "rsitems/rsitem.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" + #include "serialiser/rstlvkeys.h" #include "serialiser/rstlvidset.h" @@ -43,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; @@ -79,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; @@ -104,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; }; /**************************************************************************/ diff --git a/libretroshare/src/rsitems/rsgxsreputationitems.cc b/libretroshare/src/rsitems/rsgxsreputationitems.cc new file mode 100644 index 000000000..7b558131a --- /dev/null +++ b/libretroshare/src/rsitems/rsgxsreputationitems.cc @@ -0,0 +1,110 @@ +/* + * libretroshare/src/serialiser: rsbanlist.cc + * + * RetroShare Serialiser. + * + * Copyright 2011 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 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 +#include "serialiser/rsbaseserial.h" +#include "rsitems/rsgxsreputationitems.h" + +#include "serialiser/rstypeserializer.h" + +/*** +#define RSSERIAL_DEBUG 1 +***/ + +#include + +/*************************************************************************/ + +void RsGxsReputationSetItem::clear() +{ + mOpinions.clear() ; +} + +void RsGxsReputationUpdateItem::clear() +{ + mOpinions.clear() ; +} + +void RsGxsReputationBannedNodeSetItem::clear() +{ + mKnownIdentities.TlvClear(); +} + +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(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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mLatestUpdate,"mLatestUpdate") ; + RsTypeSerializer::serial_process (j,ctx,mOpinions,"mOpinions") ; +} +void RsGxsReputationRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mLastUpdate,"mLastUpdate") ; +} + +/*************************************************************************/ + +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/rsitems/rsgxsreputationitems.h similarity index 62% rename from libretroshare/src/serialiser/rsgxsreputationitems.h rename to libretroshare/src/rsitems/rsgxsreputationitems.h index 0fdc40ee2..d4134f745 100644 --- a/libretroshare/src/serialiser/rsgxsreputationitems.h +++ b/libretroshare/src/rsitems/rsgxsreputationitems.h @@ -28,12 +28,17 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" + #include "serialiser/rsserial.h" #include "serialiser/rstlvidset.h" #include "retroshare/rsgxsifacetypes.h" #include "retroshare/rsreputations.h" +#include "serialiser/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 +58,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 +68,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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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 +87,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 +97,8 @@ public: RsPgpId mOwnerNodeId; std::map mOpinions; // RsPeerId -> Opinion. }; +#endif + class RsGxsReputationSetItem: public RsReputationItem { public: @@ -116,10 +112,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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; RsGxsId mGxsId; uint32_t mOwnOpinion; @@ -136,10 +130,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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; RsPgpId mPgpId ; uint32_t mLastActivityTS ; @@ -153,12 +145,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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; - uint32_t mLatestUpdate; + uint32_t mLatestUpdate; std::map mOpinions; // GxsId -> Opinion. }; @@ -169,40 +159,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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::SerializeContext& /* ctx */) ; uint32_t mLastUpdate; }; -class RsGxsReputationSerialiser: public RsSerialType +class RsGxsReputationSerialiser: public RsServiceSerializer { public: - RsGxsReputationSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_REPUTATION){} - + RsGxsReputationSerialiser() :RsServiceSerializer(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/rsitems/rsgxsupdateitems.cc b/libretroshare/src/rsitems/rsgxsupdateitems.cc new file mode 100644 index 000000000..50f154cb2 --- /dev/null +++ b/libretroshare/src/rsitems/rsgxsupdateitems.cc @@ -0,0 +1,138 @@ +/* + * libretroshare/src/serialiser: rsgxsupdateitems.h + * + * RetroShare Serialiser. + * + * Copyright 2012 Christopher Evi-Parker + * + * 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 "serialiser/rstypeserializer.h" +#include "serialiser/rsbaseserial.h" + +#include "rsgxsupdateitems.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 */ +/**********************************************************************************************/ + +void RsGxsGrpUpdateItem::clear() +{ + grpUpdateTS = 0; + peerID.clear(); +} + +void RsGxsMsgUpdateItem::clear() +{ + msgUpdateInfos.clear(); + peerID.clear(); +} + +void RsGxsServerMsgUpdateItem::clear() +{ + msgUpdateTS = 0; + grpId.clear(); +} + +void RsGxsServerGrpUpdateItem::clear() +{ + grpUpdateTS = 0; +} + +/**********************************************************************************************/ +/* SERIALISER */ +/**********************************************************************************************/ + +void RsGxsGrpUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,peerID,"peerID"); + RsTypeSerializer::serial_process(j,ctx,grpUpdateTS,"grpUpdateTS"); +} + +void RsGxsServerGrpUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,grpUpdateTS,"grpUpdateTS"); +} + +void RsGxsMsgUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,peerID,"peerID"); + RsTypeSerializer::serial_process(j,ctx,msgUpdateInfos,"msgUpdateInfos"); +} + +template<> bool RsTypeSerializer::serialize(uint8_t data[], uint32_t size, uint32_t &offset, const RsGxsMsgUpdateItem::MsgUpdateInfo& info) +{ + bool ok = true ; + + ok = ok && setRawUInt32(data,size,&offset,info.time_stamp); + ok = ok && setRawUInt32(data,size,&offset,info.message_count); + + return ok; +} +template<> bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, RsGxsMsgUpdateItem::MsgUpdateInfo& info) +{ + bool ok = true ; + + ok = ok && getRawUInt32(data,size,&offset,&info.time_stamp); + ok = ok && getRawUInt32(data,size,&offset,&info.message_count); + + return ok; +} +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) +{ + std::cerr << "[MsgUpdateInfo]: " << name << ": " << info.time_stamp << ", " << info.message_count << std::endl; +} + +void RsGxsServerMsgUpdateItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process (j,ctx,grpId,"grpId"); + RsTypeSerializer::serial_process(j,ctx,msgUpdateTS,"msgUpdateTS"); +} +void RsGxsGrpConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + 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") ; +} + + diff --git a/libretroshare/src/serialiser/rsgxsupdateitems.h b/libretroshare/src/rsitems/rsgxsupdateitems.h similarity index 68% rename from libretroshare/src/serialiser/rsgxsupdateitems.h rename to libretroshare/src/rsitems/rsgxsupdateitems.h index b7d6f324c..8ea020fe5 100644 --- a/libretroshare/src/serialiser/rsgxsupdateitems.h +++ b/libretroshare/src/rsitems/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" @@ -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/serialiser/rsheartbeatitems.h b/libretroshare/src/rsitems/rsheartbeatitems.h similarity index 61% rename from libretroshare/src/serialiser/rsheartbeatitems.h rename to libretroshare/src/rsitems/rsheartbeatitems.h index cfabae2ee..87d480b3e 100644 --- a/libretroshare/src/serialiser/rsheartbeatitems.h +++ b/libretroshare/src/rsitems/rsheartbeatitems.h @@ -28,8 +28,9 @@ #ifndef RS_HEARTBEAT_ITEMS_H #define RS_HEARTBEAT_ITEMS_H -#include "serialiser/rsserial.h" -#include "serialiser/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" const uint8_t RS_PKT_SUBTYPE_HEARTBEAT_PULSE = 0x01; @@ -41,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/rsitems/rshistoryitems.cc b/libretroshare/src/rsitems/rshistoryitems.cc new file mode 100644 index 000000000..a66299b51 --- /dev/null +++ b/libretroshare/src/rsitems/rshistoryitems.cc @@ -0,0 +1,75 @@ +/* + * libretroshare/src/serialiser: rshistoryitems.cc + * + * RetroShare Serialiser. + * + * Copyright 2011 by Thunder. + * + * 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/rshistoryitems.h" +#include "rsitems/rsconfigitems.h" + +#include "serialiser/rsbaseserial.h" +#include "serialiser/rstlvbase.h" + +#include "serialiser/rstypeserializer.h" + +/*** +#define RSSERIAL_DEBUG 1 +***/ + +#include + +void RsHistoryMsgItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 item_type,uint8_t item_subtype) const +{ + if(item_type != RS_PKT_TYPE_HISTORY_CONFIG) + return NULL ; + + if(item_subtype == 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) +{ + incoming = false; + sendTime = 0; + recvTime = 0; + msgId = 0; + saveToDisc = true; +} + + diff --git a/libretroshare/src/serialiser/rshistoryitems.h b/libretroshare/src/rsitems/rshistoryitems.h similarity index 66% rename from libretroshare/src/serialiser/rshistoryitems.h rename to libretroshare/src/rsitems/rshistoryitems.h index 039bf095f..802754e91 100644 --- a/libretroshare/src/serialiser/rshistoryitems.h +++ b/libretroshare/src/rsitems/rshistoryitems.h @@ -26,20 +26,23 @@ * */ -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" +#include "rsitems/rsconfigitems.h" #include "retroshare/rstypes.h" +#include "serialiser/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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 item_type,uint8_t item_subtype) const ; }; /**************************************************************************/ diff --git a/libretroshare/src/rsitems/rsitem.h b/libretroshare/src/rsitems/rsitem.h new file mode 100644 index 000000000..8dbda2fb3 --- /dev/null +++ b/libretroshare/src/rsitems/rsitem.h @@ -0,0 +1,90 @@ +#pragma once + +#include "util/smallobject.h" +#include "retroshare/rstypes.h" +#include "serialiser/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 new file mode 100644 index 000000000..09f305fc7 --- /dev/null +++ b/libretroshare/src/rsitems/rsmsgitems.cc @@ -0,0 +1,182 @@ + +/* + * libretroshare/src/serialiser: rsbaseitems.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 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 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 +#include "serialiser/rsbaseserial.h" +#include "serialiser/rstlvbase.h" + +#include "rsitems/rsmsgitems.h" + +#include "serialiser/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; + msgFlags = 0; + sendTime = 0; + recvTime = 0; + subject.clear(); + message.clear(); + + rspeerid_msgto.TlvClear(); + rspeerid_msgcc.TlvClear(); + rspeerid_msgbcc.TlvClear(); + + rsgxsid_msgto.TlvClear(); + rsgxsid_msgcc.TlvClear(); + rsgxsid_msgbcc.TlvClear(); + + attachment.TlvClear(); +} + +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(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(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 == RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,msgId,"msgId") ; + RsTypeSerializer::serial_process (j,ctx,srcId,"srcId") ; +} + +void RsMsgGRouterMap::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,ongoing_msgs,"ongoing_msgs") ; +} + +void RsMsgGRouterMap::clear() +{ + ongoing_msgs.clear() ; + + return; +} + +void RsMsgDistantMessagesHashMap::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,hash_map,"hash_map") ; +} + +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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 & RsServiceSerializer::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(); +} + diff --git a/libretroshare/src/serialiser/rsmsgitems.h b/libretroshare/src/rsitems/rsmsgitems.h similarity index 65% rename from libretroshare/src/serialiser/rsmsgitems.h rename to libretroshare/src/rsitems/rsmsgitems.h index 1a7e84cd0..527c43fdf 100644 --- a/libretroshare/src/serialiser/rsmsgitems.h +++ b/libretroshare/src/rsitems/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" @@ -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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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(RsGenericSerializer::SerializeJob /* j */,RsGenericSerializer::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 RsServiceSerializer { 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) + :RsServiceSerializer(RS_SERVICE_TYPE_MSG,RsGenericSerializer::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/rsitems/rsnxsitems.cc b/libretroshare/src/rsitems/rsnxsitems.cc new file mode 100644 index 000000000..104935930 --- /dev/null +++ b/libretroshare/src/rsitems/rsnxsitems.cc @@ -0,0 +1,215 @@ +#include "rsnxsitems.h" +#include "util/rsprint.h" +#include + +#include "serialiser/rstypeserializer.h" + +/*** + * #define RSSERIAL_DEBUG 1 + ***/ + +const uint8_t RsNxsSyncGrpItem::FLAG_REQUEST = 0x001; +const uint8_t RsNxsSyncGrpItem::FLAG_RESPONSE = 0x002; + +const uint8_t RsNxsSyncMsgItem::FLAG_REQUEST = 0x001; +const uint8_t RsNxsSyncMsgItem::FLAG_RESPONSE = 0x002; + +const uint8_t RsNxsSyncGrpItem::FLAG_USE_SYNC_HASH = 0x0001; +const uint8_t RsNxsSyncMsgItem::FLAG_USE_SYNC_HASH = 0x0001; + +const uint8_t RsNxsSyncMsgReqItem::FLAG_USE_HASHED_GROUP_ID = 0x02; + +/** transaction state **/ +const uint16_t RsNxsTransacItem::FLAG_BEGIN_P1 = 0x0001; +const uint16_t RsNxsTransacItem::FLAG_BEGIN_P2 = 0x0002; +const uint16_t RsNxsTransacItem::FLAG_END_SUCCESS = 0x0004; +const uint16_t RsNxsTransacItem::FLAG_CANCEL = 0x0008; +const uint16_t RsNxsTransacItem::FLAG_END_FAIL_NUM = 0x0010; +const uint16_t RsNxsTransacItem::FLAG_END_FAIL_TIMEOUT = 0x0020; +const uint16_t RsNxsTransacItem::FLAG_END_FAIL_FULL = 0x0040; + + +/** transaction type **/ +const uint16_t RsNxsTransacItem::FLAG_TYPE_GRP_LIST_RESP = 0x0100; +const uint16_t RsNxsTransacItem::FLAG_TYPE_MSG_LIST_RESP = 0x0200; +const uint16_t RsNxsTransacItem::FLAG_TYPE_GRP_LIST_REQ = 0x0400; +const uint16_t RsNxsTransacItem::FLAG_TYPE_MSG_LIST_REQ = 0x0800; +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::create_item(uint16_t service_id,uint8_t item_subtype) const +{ + if(service_id != SERVICE_TYPE) + return NULL ; + + 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: + 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 + + diff --git a/libretroshare/src/serialiser/rsnxsitems.h b/libretroshare/src/rsitems/rsnxsitems.h similarity index 65% rename from libretroshare/src/serialiser/rsnxsitems.h rename to libretroshare/src/rsitems/rsnxsitems.h index 88f0ca914..10eb1d835 100644 --- a/libretroshare/src/serialiser/rsnxsitems.h +++ b/libretroshare/src/rsitems/rsnxsitems.h @@ -30,7 +30,8 @@ #include #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" #include "serialiser/rsserial.h" #include "serialiser/rstlvbase.h" #include "serialiser/rstlvitem.h" @@ -71,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 }; @@ -102,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 @@ -126,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 @@ -148,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 ; }; @@ -193,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; @@ -223,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 @@ -243,6 +224,7 @@ public: }; +#ifdef SUSPENDED_CODE_27042017 /*! * Use to send to peer list of grps * held by server peer @@ -255,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 @@ -281,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 /// @@ -305,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; @@ -353,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; @@ -379,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; @@ -404,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 @@ -452,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 @@ -476,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 @@ -503,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; @@ -546,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; }; diff --git a/libretroshare/src/rsitems/rsphotoitems.cc b/libretroshare/src/rsitems/rsphotoitems.cc new file mode 100644 index 000000000..9c9ff2d02 --- /dev/null +++ b/libretroshare/src/rsitems/rsphotoitems.cc @@ -0,0 +1,120 @@ +/* + * libretroshare/src/retroshare: rsphoto.h + * + * RetroShare C++ Interface. + * + * Copyright 2012-2012 by Christopher Evi-Parker, 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 + +#include "rsitems/rsphotoitems.h" + +#include "serialiser/rstlvbinary.h" +#include "serialiser/rstypeserializer.h" + +#define GXS_PHOTO_SERIAL_DEBUG + + +RsItem *RsGxsPhotoSerialiser::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 ; + } +} + +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") ; +} +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") ; +} +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"); +} + +void RsGxsPhotoAlbumItem::clear() +{ + album.mCaption.clear(); + album.mCategory.clear(); + album.mDescription.clear(); + album.mHashTags.clear(); + album.mOther.clear(); + album.mPhotoPath.clear(); + album.mPhotographer.clear(); + album.mWhen.clear(); + album.mWhere.clear(); + album.mThumbnail.deleteImage(); +} + +void RsGxsPhotoCommentItem::clear() +{ + comment.mComment.clear(); + comment.mCommentFlag = 0; +} + +void RsGxsPhotoPhotoItem::clear() +{ + photo.mCaption.clear(); + photo.mCategory.clear(); + photo.mDescription.clear(); + photo.mHashTags.clear(); + photo.mOther.clear(); + photo.mPhotographer.clear(); + photo.mWhen.clear(); + photo.mWhere.clear(); + photo.mThumbnail.deleteImage(); +} diff --git a/libretroshare/src/rsitems/rsphotoitems.h b/libretroshare/src/rsitems/rsphotoitems.h new file mode 100644 index 000000000..3819edb88 --- /dev/null +++ b/libretroshare/src/rsitems/rsphotoitems.h @@ -0,0 +1,96 @@ +/* + * libretroshare/src/retroshare: rsphoto.h + * + * RetroShare C++ Interface. + * + * Copyright 2012-2012 by Christopher Evi-Parker, 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". + * + */ + +#ifndef RSPHOTOV2ITEMS_H_ +#define RSPHOTOV2ITEMS_H_ + +#include + +#include "rsitems/rsserviceids.h" +#include "rsitems/rsgxsitems.h" + +#include "serialiser/rsserial.h" +#include "serialiser/rsserializer.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_COMMENT_ITEM = 0x04; + +class RsGxsPhotoAlbumItem : public RsGxsGrpItem +{ + +public: + + RsGxsPhotoAlbumItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_PHOTO, + RS_PKT_SUBTYPE_PHOTO_ITEM) { return;} + virtual ~RsGxsPhotoAlbumItem() { return;} + + void clear(); + std::ostream &print(std::ostream &out, uint16_t indent = 0); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsPhotoAlbum album; +}; + +class RsGxsPhotoPhotoItem : public RsGxsMsgItem +{ +public: + + 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; +}; + +class RsGxsPhotoCommentItem : public RsGxsMsgItem +{ +public: + + RsGxsPhotoCommentItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_PHOTO, RS_PKT_SUBTYPE_PHOTO_COMMENT_ITEM) {} + virtual ~RsGxsPhotoCommentItem() {} + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsPhotoComment comment; +}; + +class RsGxsPhotoSerialiser : public RsServiceSerializer +{ +public: + + 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/rspluginitems.h b/libretroshare/src/rsitems/rspluginitems.h similarity index 58% rename from libretroshare/src/serialiser/rspluginitems.h rename to libretroshare/src/rsitems/rspluginitems.h index ed2bda137..f5ff61321 100644 --- a/libretroshare/src/serialiser/rspluginitems.h +++ b/libretroshare/src/rsitems/rspluginitems.h @@ -26,14 +26,10 @@ #pragma once -#include "serialiser/rsserial.h" -#include "serialiser/rsconfigitems.h" -#include "serialiser/rsbaseserial.h" +#include "rsitems/rsitem.h" +#include "rsitems/rsconfigitems.h" -#if 0 -#include "serialiser/rstlvbase.h" -#include "serialiser/rstlvtypes.h" -#endif +#include "serialiser/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 ; + } }; diff --git a/libretroshare/src/rsitems/rsposteditems.cc b/libretroshare/src/rsitems/rsposteditems.cc new file mode 100644 index 000000000..378153df3 --- /dev/null +++ b/libretroshare/src/rsitems/rsposteditems.cc @@ -0,0 +1,63 @@ + +/* + * libretroshare/src/gxs: rsopsteditems.cc + * + * RetroShare Serialiser. + * + * Copyright 2012-2013 by Robert Fernie, Christopher Evi-Parker + * + * 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 "rsitems/rsposteditems.h" +#include "serialiser/rstypeserializer.h" + +void RsGxsPostedPostItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + 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") ; +} + +void RsGxsPostedGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR ,mGroup.mDescription,"mGroup.mDescription") ; +} + +RsItem *RsGxsPostedSerialiser::create_item(uint16_t service_id,uint8_t item_subtype) const +{ + if(service_id != RS_SERVICE_GXS_TYPE_POSTED) + return NULL ; + + 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(); +} +void RsGxsPostedGroupItem::clear() +{ + mGroup.mDescription.clear(); +} diff --git a/libretroshare/src/rsitems/rsposteditems.h b/libretroshare/src/rsitems/rsposteditems.h new file mode 100644 index 000000000..b78835451 --- /dev/null +++ b/libretroshare/src/rsitems/rsposteditems.h @@ -0,0 +1,49 @@ +#ifndef RSPOSTEDITEMS_H +#define RSPOSTEDITEMS_H + +#include "rsitems/rsserviceids.h" +#include "rsitems/rsgxscommentitems.h" +#include "rsitems/rsgxsitems.h" + +#include "retroshare/rsposted.h" + +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) {} + virtual ~RsGxsPostedGroupItem() {} + + void clear(); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsPostedGroup mGroup; +}; + +class RsGxsPostedPostItem : public RsGxsMsgItem +{ +public: + RsGxsPostedPostItem() : RsGxsMsgItem(RS_SERVICE_GXS_TYPE_POSTED, RS_PKT_SUBTYPE_POSTED_POST_ITEM) {} + virtual ~RsGxsPostedPostItem() {} + + void clear(); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsPostedPost mPost; +}; + +class RsGxsPostedSerialiser : public RsGxsCommentSerialiser +{ +public: + + RsGxsPostedSerialiser() :RsGxsCommentSerialiser(RS_SERVICE_GXS_TYPE_POSTED) {} + + virtual ~RsGxsPostedSerialiser() {} + + virtual RsItem *create_item(uint16_t service_id,uint8_t item_subtype) const ; +}; + + +#endif // RSPOSTEDITEMS_H diff --git a/libretroshare/src/rsitems/rsrttitems.cc b/libretroshare/src/rsitems/rsrttitems.cc new file mode 100644 index 000000000..033975a3b --- /dev/null +++ b/libretroshare/src/rsitems/rsrttitems.cc @@ -0,0 +1,67 @@ + +/* + * libretroshare/src/serialiser: rsrttitems.cc + * + * RetroShare Serialiser. + * + * Copyright 2011-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". + * + */ + +#include "rsitems/rsrttitems.h" + +/*** +#define RSSERIAL_DEBUG 1 +***/ + +#include + +#include "serialiser/rstypeserializer.h" + +/*************************************************************************/ + +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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,mSeqNo,"mSeqNo") ; + RsTypeSerializer::serial_process(j,ctx,mPingTS,"mPingTS") ; +} + +void RsRttPongItem::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") ; +} + + + diff --git a/libretroshare/src/serialiser/rsrttitems.h b/libretroshare/src/rsitems/rsrttitems.h similarity index 58% rename from libretroshare/src/serialiser/rsrttitems.h rename to libretroshare/src/rsitems/rsrttitems.h index 2ebbbb51b..35cf85bae 100644 --- a/libretroshare/src/serialiser/rsrttitems.h +++ b/libretroshare/src/rsitems/rsrttitems.h @@ -28,9 +28,13 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" #include "serialiser/rsserial.h" +#include "serialiser/rsserializer.h" + /**************************************************************************/ const uint8_t RS_PKT_SUBTYPE_RTT_PING = 0x01; @@ -39,12 +43,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 +55,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t mSeqNo; uint64_t mPingTS; @@ -65,9 +69,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); uint32_t mSeqNo; uint64_t mPingTS; @@ -75,29 +80,14 @@ class RsRttPongItem: public RsRttItem }; -class RsRttSerialiser: public RsSerialType +class RsRttSerialiser: public RsServiceSerializer { public: - RsRttSerialiser() - :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_RTT) - { return; } + RsRttSerialiser() :RsServiceSerializer(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/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/rsitems/rsserviceinfoitems.cc b/libretroshare/src/rsitems/rsserviceinfoitems.cc new file mode 100644 index 000000000..d0d2070ab --- /dev/null +++ b/libretroshare/src/rsitems/rsserviceinfoitems.cc @@ -0,0 +1,173 @@ +/* + * libretroshare/src/serialiser: rsserviceinfoitems.cc + * + * RetroShare Serialiser. + * + * Copyright 2014 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 "serialiser/rsbaseserial.h" +#include "serialiser/rstypeserializer.h" +#include "rsitems/rsserviceinfoitems.h" + +/*** +#define RSSERIAL_DEBUG 1 +***/ + +#include + +/*************************************************************************/ +/***** 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 +{ + out << "RsServiceInfo: " << mParam.mServiceType << " name " << mParam.mServiceName; + out << std::endl; + out << "Version(" << mParam.mVersionMajor << "," << mParam.mVersionMinor << ")"; + out << " MinVersion(" << mParam.mMinVersionMajor << "," << mParam.mMinVersionMinor << ")"; + out << std::endl; + return out; +} + +template<> +uint32_t RsTlvParamRef::TlvSize() const +{ + uint32_t s = TLV_HEADER_SIZE; /* header + 4 for size */ + + s += getRawStringSize(mParam.mServiceName); + s += 4; // type. + s += 4; // version. + s += 4; // min version. + return s; +} + +template<> +void RsTlvParamRef::TlvClear() +{ + mParam = RsServiceInfo(); + mParam.mServiceName.clear(); +} + +template<> +bool RsTlvParamRef::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; + + ok &= SetTlvBase(data, tlvend, offset, mParamType, tlvsize); + ok &= setRawString(data, tlvend, offset, mParam.mServiceName); + ok &= setRawUInt32(data, tlvend, offset, mParam.mServiceType); + ok &= setRawUInt16(data, tlvend, offset, mParam.mVersionMajor); + ok &= setRawUInt16(data, tlvend, offset, mParam.mVersionMinor); + ok &= setRawUInt16(data, tlvend, offset, mParam.mMinVersionMajor); + ok &= setRawUInt16(data, tlvend, offset, mParam.mMinVersionMinor); + + if (!ok) + { + std::cerr << "RsTlvParamRef::SetTlv() Failed"; + std::cerr << std::endl; + } + + return ok; +} + +template<> +bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) +{ + if (size < *offset + TLV_HEADER_SIZE) + return false; + + uint16_t tlvtype = 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 (tlvtype != mParamType) /* check type */ + { + return false; + } + + bool ok = true; + + /* ready to load */ + TlvClear(); + + /* skip the header */ + (*offset) += TLV_HEADER_SIZE; + + ok &= getRawString(data, tlvend, offset, mParam.mServiceName); + ok &= getRawUInt32(data, tlvend, offset, &(mParam.mServiceType)); + ok &= getRawUInt16(data, tlvend, offset, &(mParam.mVersionMajor)); + ok &= getRawUInt16(data, tlvend, offset, &(mParam.mVersionMinor)); + ok &= getRawUInt16(data, tlvend, offset, &(mParam.mMinVersionMajor)); + ok &= getRawUInt16(data, tlvend, offset, &(mParam.mMinVersionMinor)); + + return ok; +} + +template class RsTlvParamRef; + diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.h b/libretroshare/src/rsitems/rsserviceinfoitems.h similarity index 58% rename from libretroshare/src/serialiser/rsserviceinfoitems.h rename to libretroshare/src/rsitems/rsserviceinfoitems.h index 295ca4f6b..04a524331 100644 --- a/libretroshare/src/serialiser/rsserviceinfoitems.h +++ b/libretroshare/src/rsitems/rsserviceinfoitems.h @@ -30,9 +30,10 @@ #include -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -#include "serialiser/rstlvbase.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/itempriorities.h" + #include "serialiser/rstlvgenericmap.h" #include "retroshare/rsservicecontrol.h" @@ -60,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/rsstatusitems.h b/libretroshare/src/rsitems/rsstatusitems.h similarity index 56% rename from libretroshare/src/serialiser/rsstatusitems.h rename to libretroshare/src/rsitems/rsstatusitems.h index 8677c2be0..8a8a946b7 100644 --- a/libretroshare/src/serialiser/rsstatusitems.h +++ b/libretroshare/src/rsitems/rsstatusitems.h @@ -26,52 +26,50 @@ * */ -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" +#include "rsitems/rsserviceids.h" +#include "rsitems/itempriorities.h" +#include "rsitems/rsitem.h" + +#include "serialiser/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 ; + } }; /**************************************************************************/ diff --git a/libretroshare/src/rsitems/rswikiitems.cc b/libretroshare/src/rsitems/rswikiitems.cc new file mode 100644 index 000000000..96f9e2768 --- /dev/null +++ b/libretroshare/src/rsitems/rswikiitems.cc @@ -0,0 +1,84 @@ +/* + * 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 "rsitems/rswikiitems.h" +#include "serialiser/rstlvbase.h" +#include "serialiser/rstypeserializer.h" + +#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 ; + } +} + +void RsGxsWikiCollectionItem::clear() +{ + collection.mDescription.clear(); + collection.mCategory.clear(); + collection.mHashTags.clear(); +} + +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") ; +} + +void RsGxsWikiSnapshotItem::clear() +{ + snapshot.mPage.clear(); + snapshot.mHashTags.clear(); +} + +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") ; +} + +void RsGxsWikiCommentItem::clear() +{ + comment.mComment.clear(); +} + +void RsGxsWikiCommentItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_COMMENT,comment.mComment,"comment.mComment") ; +} + diff --git a/libretroshare/src/rsitems/rswikiitems.h b/libretroshare/src/rsitems/rswikiitems.h new file mode 100644 index 000000000..378b77e5a --- /dev/null +++ b/libretroshare/src/rsitems/rswikiitems.h @@ -0,0 +1,90 @@ +/* + * libretroshare/src/serialiser: rswikiitems.h + * + * 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". + * + */ + +#ifndef RS_WIKI_ITEMS_H +#define RS_WIKI_ITEMS_H + +#include + +#include "rsitems/rsserviceids.h" +#include "rsitems/rsitem.h" +#include "rsitems/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; + +class RsGxsWikiCollectionItem : public RsGxsGrpItem +{ +public: + RsGxsWikiCollectionItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_WIKI, RS_PKT_SUBTYPE_WIKI_COLLECTION_ITEM) {} + virtual ~RsGxsWikiCollectionItem() {} + + void clear(); + + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsWikiCollection collection; +}; + +class RsGxsWikiSnapshotItem : public RsGxsMsgItem +{ +public: + + 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; +}; + +class RsGxsWikiCommentItem : public RsGxsMsgItem +{ +public: + + RsGxsWikiCommentItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_WIKI, RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM) {} + virtual ~RsGxsWikiCommentItem() {} + void clear(); + virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); + + RsWikiComment comment; + +}; + +class RsGxsWikiSerialiser : public RsServiceSerializer +{ +public: + + 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/rsitems/rswireitems.cc b/libretroshare/src/rsitems/rswireitems.cc new file mode 100644 index 000000000..7a8008ff8 --- /dev/null +++ b/libretroshare/src/rsitems/rswireitems.cc @@ -0,0 +1,64 @@ +/* + * 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 "rswireitems.h" + +#include "serialiser/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 ; + } +} + +void RsGxsWireGroupItem::clear() +{ + group.mDescription.clear(); +} + +void RsGxsWireGroupItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) +{ + RsTypeSerializer::serial_process(j,ctx,TLV_TYPE_STR_DESCR,group.mDescription,"group.mDescription") ; +} + +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") ; +} + diff --git a/libretroshare/src/serialiser/rswireitems.h b/libretroshare/src/rsitems/rswireitems.h similarity index 50% rename from libretroshare/src/serialiser/rswireitems.h rename to libretroshare/src/rsitems/rswireitems.h index 72d1732a6..137619aa6 100644 --- a/libretroshare/src/serialiser/rswireitems.h +++ b/libretroshare/src/rsitems/rswireitems.h @@ -28,7 +28,7 @@ #include -#include "serialiser/rsserviceids.h" +#include "rsitems/rsserviceids.h" #include "serialiser/rsserial.h" //#include "serialiser/rstlvtypes.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 */ diff --git a/libretroshare/src/serialiser/rsbanlistitems.cc b/libretroshare/src/serialiser/rsbanlistitems.cc deleted file mode 100644 index b22c16d2b..000000000 --- a/libretroshare/src/serialiser/rsbanlistitems.cc +++ /dev/null @@ -1,334 +0,0 @@ -/* - * libretroshare/src/serialiser: rsbanlist.cc - * - * RetroShare Serialiser. - * - * Copyright 2011 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 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 "serialiser/rsbaseserial.h" -#include "serialiser/rsbanlistitems.h" -#include "serialiser/rstlvbanlist.h" - -/*** -#define RSSERIAL_DEBUG 1 -***/ - -#include - -/*************************************************************************/ - -RsBanListItem::~RsBanListItem() -{ - return; -} - -void RsBanListItem::clear() -{ - peerList.TlvClear(); -} - -std::ostream &RsBanListItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsBanListItem", indent); - uint16_t int_Indent = indent + 2; - peerList.print(out, int_Indent); - - printRsItemEnd(out, "RsBanListItem", indent); - return out; -} - - -uint32_t RsBanListSerialiser::sizeList(RsBanListItem *item) -{ - uint32_t s = 8; /* header */ - s += item->peerList.TlvSize(); - - return s; -} - -uint32_t RsBanListSerialiser::sizeListConfig(RsBanListConfigItem *item) -{ - uint32_t s = 8; /* header */ - s += 4 ; // type - s += item->banned_peers.TlvSize(); - s += 8 ; // update time - s += item->peerId.serial_size() ; - - 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) - { - 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; - } -} - -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/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/rsbwctrlitems.cc b/libretroshare/src/serialiser/rsbwctrlitems.cc deleted file mode 100644 index fbd314bb2..000000000 --- a/libretroshare/src/serialiser/rsbwctrlitems.cc +++ /dev/null @@ -1,205 +0,0 @@ -/* - * libretroshare/src/serialiser: rsbwctrlitems.cc - * - * RetroShare Serialiser. - * - * Copyright 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 "serialiser/rsbaseserial.h" -#include "serialiser/rsbwctrlitems.h" - -/*** -#define RSSERIAL_DEBUG 1 -***/ - -#include - -/*************************************************************************/ - -RsBwCtrlAllowedItem::~RsBwCtrlAllowedItem() -{ - return; -} - -void RsBwCtrlAllowedItem::clear() -{ - allowedBw = 0; -} - -std::ostream &RsBwCtrlAllowedItem::print(std::ostream &out, uint16_t indent) -{ - 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; -} - -/* 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; - } -} - -/*************************************************************************/ - - - diff --git a/libretroshare/src/serialiser/rsconfigitems.cc b/libretroshare/src/serialiser/rsconfigitems.cc deleted file mode 100644 index 9b94d454d..000000000 --- a/libretroshare/src/serialiser/rsconfigitems.cc +++ /dev/null @@ -1,1937 +0,0 @@ - -/* - * libretroshare/src/serialiser: rsconfigitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2007-2008 by Robert Fernie, Chris Parker. - * - * 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 "serialiser/rsbaseserial.h" -#include "serialiser/rsconfigitems.h" -#include "retroshare/rspeers.h" // Needed for RsGroupInfo. - -/*** - * #define RSSERIAL_DEBUG 1 - * #define RSSERIAL_ERROR_DEBUG 1 - ***/ - -#define RSSERIAL_ERROR_DEBUG 1 - -#include - - -/*************************************************************************/ - -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; -} - -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); - 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; -} - -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; -} - -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; -} - -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; -} - -/* 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; -} - -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; -} - -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) -{ - 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; -} - -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; -} - -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; - -} - -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; -} - -/*************************************************************************/ -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() -{ - 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; -} - -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; -} - -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; -} - - - - - diff --git a/libretroshare/src/serialiser/rsconfigitems.h b/libretroshare/src/serialiser/rsconfigitems.h deleted file mode 100644 index 3d3d50a97..000000000 --- a/libretroshare/src/serialiser/rsconfigitems.h +++ /dev/null @@ -1,435 +0,0 @@ -#ifndef RS_CONFIG_ITEMS_SERIALISER_H -#define RS_CONFIG_ITEMS_SERIALISER_H - -/* - * libretroshare/src/serialiser: rsconfigitems.h - * - * RetroShare Serialiser. - * - * Copyright 2007-2008 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 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 - -#include "retroshare/rstypes.h" -#include "serialiser/rsserial.h" - -#include "serialiser/rstlvidset.h" -#include "serialiser/rstlvfileitem.h" -#include "serialiser/rstlvkeyvalue.h" -#include "serialiser/rstlvaddrs.h" - -class RsGroupInfo; - -const uint8_t RS_PKT_TYPE_GENERAL_CONFIG = 0x01; -const uint8_t RS_PKT_TYPE_PEER_CONFIG = 0x02; -const uint8_t RS_PKT_TYPE_CACHE_CONFIG = 0x03; -const uint8_t RS_PKT_TYPE_FILE_CONFIG = 0x04; -const uint8_t RS_PKT_TYPE_PLUGIN_CONFIG = 0x05; -const uint8_t RS_PKT_TYPE_HISTORY_CONFIG = 0x06; - - /* GENERAL CONFIG SUBTYPES */ -const uint8_t RS_PKT_SUBTYPE_KEY_VALUE = 0x01; - - /* PEER CONFIG SUBTYPES */ -const uint8_t RS_PKT_SUBTYPE_PEER_STUN = 0x02; -const uint8_t RS_PKT_SUBTYPE_PEER_NET = 0x03; -const uint8_t RS_PKT_SUBTYPE_PEER_GROUP_deprecated = 0x04; -const uint8_t RS_PKT_SUBTYPE_PEER_PERMISSIONS = 0x05; -const uint8_t RS_PKT_SUBTYPE_PEER_BANDLIMITS = 0x06; -const uint8_t RS_PKT_SUBTYPE_NODE_GROUP = 0x07; - - /* FILE CONFIG SUBTYPES */ -const uint8_t RS_PKT_SUBTYPE_FILE_TRANSFER = 0x01; -const uint8_t RS_PKT_SUBTYPE_FILE_ITEM_deprecated = 0x02; -const uint8_t RS_PKT_SUBTYPE_FILE_ITEM = 0x03; - -/**************************************************************************/ - -// We should make these items use a clean serialise code, and all derive from the same item type. - -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); - - /* networking information */ - RsPeerId peerId; /* 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 */ - - RsTlvIpAddress localAddrV4; /* Mandatory */ - RsTlvIpAddress extAddrV4; /* Mandatory */ - RsTlvIpAddress localAddrV6; /* Mandatory */ - RsTlvIpAddress extAddrV6; /* Mandatory */ - - std::string dyndns; - - RsTlvIpAddrSet localAddrList; - RsTlvIpAddrSet extAddrList; - - // for proxy connection. - std::string domain_addr; - uint16_t domain_port; -}; - -// This item should be merged with the next item, but that is not backward compatible. -class RsPeerServicePermissionItem : public RsItem -{ - public: - RsPeerServicePermissionItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_PEER_PERMISSIONS) {} - virtual ~RsPeerServicePermissionItem() {} - - virtual void clear() - { - pgp_ids.clear() ; - service_flags.clear() ; - } - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - /* Mandatory */ - std::vector pgp_ids ; - std::vector service_flags ; -}; -class RsPeerBandwidthLimitsItem : public RsItem -{ - public: - RsPeerBandwidthLimitsItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_PEER_CONFIG, RS_PKT_SUBTYPE_PEER_BANDLIMITS) {} - virtual ~RsPeerBandwidthLimitsItem() {} - - virtual void clear() - { - peers.clear() ; - } - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - /* Mandatory */ - std::map peers ; -}; - -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; -}; - -class RsNodeGroupItem: public RsItem -{ -public: - RsNodeGroupItem(); - virtual ~RsNodeGroupItem() {} - - virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - explicit RsNodeGroupItem(const RsGroupInfo&) ; - - // /* set data from RsGroupInfo to RsPeerGroupItem */ - // void set(RsGroupInfo &groupInfo); - // /* get data from RsGroupInfo to RsPeerGroupItem */ - // void get(RsGroupInfo &groupInfo); - - /* Mandatory */ - RsNodeGroupId id; - std::string name; - uint32_t flag; - - RsTlvPgpIdSet pgpList; -}; - -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); - - RsTlvPeerIdSet stunList; /* Mandatory */ -}; - -class RsPeerConfigSerialiser: public RsSerialType -{ - public: - RsPeerConfigSerialiser() - :RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_PEER_CONFIG) - { return; } - -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); - - 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); -}; - -/**************************************************************************/ -/**************************************************************************/ - -/**************************************************************************/ - -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); - -}; - -/**************************************************************************/ - -class RsFileTransfer: public RsItem -{ - public: - RsFileTransfer() :RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_FILE_CONFIG, RS_PKT_SUBTYPE_FILE_TRANSFER) - { - state = 0; - in = 0; - transferred = 0; - crate = 0; - trate = 0; - lrate = 0; - ltransfer = 0; - flags = 0; - chunk_strategy = 0; - } - virtual ~RsFileTransfer(); - virtual void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - RsTlvFileItem file; - RsTlvPeerIdSet allPeerIds; - - RsPeerId cPeerId; - - uint16_t state; - uint16_t in; - - uint64_t transferred; - uint32_t crate; - uint32_t trate; - - uint32_t lrate; - uint32_t ltransfer; - - // chunk information - uint32_t flags ; - uint32_t chunk_strategy ; // strategy flags for chunks - CompressedChunkMap compressed_chunk_map ; // chunk availability (bitwise) -}; - -/**************************************************************************/ - -const uint32_t RS_FILE_CONFIG_CLEANUP_DELETE = 0x0001; - -/* 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 ; -}; - -class RsFileConfigItem: public RsItem -{ -public: - 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); - - RsTlvFileItem file; - uint32_t flags; - RsTlvNodeGroupIdSet parent_groups ; -}; -/**************************************************************************/ - -class RsFileConfigSerialiser: public RsSerialType -{ - public: - RsFileConfigSerialiser() - :RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, - RS_PKT_TYPE_FILE_CONFIG) - { return; } -virtual ~RsFileConfigSerialiser() { 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 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); - -}; - -/**************************************************************************/ - -/* Config items that are used generally */ - -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); - - RsTlvKeyValueSet tlvkvs; -}; - - -class RsGeneralConfigSerialiser: public RsSerialType -{ - 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); - -}; - -#endif /* RS_CONFIG_ITEMS_SERIALISER_H */ diff --git a/libretroshare/src/serialiser/rsdiscovery2items.cc b/libretroshare/src/serialiser/rsdiscovery2items.cc deleted file mode 100644 index 611a7e80a..000000000 --- a/libretroshare/src/serialiser/rsdiscovery2items.cc +++ /dev/null @@ -1,898 +0,0 @@ - -/* - * libretroshare/src/serialiser: rsdiscitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2007-2008 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 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 "serialiser/rsdiscovery2items.h" -#include "serialiser/rsbaseserial.h" - -#if 0 - -#include "serialiser/rsserviceids.h" - -#include "serialiser/rstlvbase.h" -#include "serialiser/rstlvtypes.h" -#endif - -/*** - * #define RSSERIAL_DEBUG 1 - * #define RSSERIAL_ERROR_DEBUG 1 - ***/ - -#define RSSERIAL_ERROR_DEBUG 1 - -#include - -/*************************************************************************/ - -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; -} - -/*************************************************************************/ - -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); - 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; -} - - -/*************************************************************************/ -/*************************************************************************/ -#if 0 - -RsDiscServicesItem::~RsDiscServicesItem() -{ - return; -} - -void RsDiscServicesItem::clear() -{ - version.clear(); - mServiceIdMap.TlvClear(); -} - -std::ostream &RsDiscServicesItem::print(std::ostream &out, uint16_t indent) -{ - printRsItemBase(out, "RsDiscServicesItem", indent); - uint16_t int_Indent = indent + 2; - - printIndent(out, int_Indent); - out << "version: " << version << std::endl; - mServiceIdMap.print(out, int_Indent); - - printRsItemEnd(out, "RsDiscServicesItem", indent); - return out; -} - - -uint32_t RsDiscSerialiser::sizeServices(RsDiscServicesItem *item) -{ - uint32_t s = 8; /* header */ - s += GetTlvStringSize(item->version); /* version */ - s += item->mServiceIdMap.TlvSize(); - return s; -} - -/* serialise the data to the buffer */ -bool RsDiscSerialiser::serialiseServices(RsDiscServicesItem *item, void *data, uint32_t *pktsize) -{ - uint32_t tlvsize = sizeServices(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::serialiseServices() Header: " << ok << std::endl; - std::cerr << "RsDiscSerialiser::serialiseServices() Size: " << tlvsize << std::endl; -#endif - - /* skip the header */ - offset += 8; - - /* add mandatory parts first */ - ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VERSION, item->version); - ok &= item->mServiceIdMap.SetTlv(data, tlvsize, &offset); - - if (offset != tlvsize) { - ok = false; -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::serialiseServices() Size Error! " << std::endl; -#endif - } - - return ok; -} - -RsDiscServicesItem *RsDiscSerialiser::deserialiseServices(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::deserialiseServices() Wrong Type" << std::endl; -#endif - return NULL; /* wrong type */ - } - - if (*pktsize < rssize) /* check size */ - { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseServices() Not Enough Space" << std::endl; -#endif - return NULL; /* not enough data */ - } - - /* set the packet length */ - *pktsize = rssize; - - bool ok = true; - - /* ready to load */ - RsDiscServicesItem *item = new RsDiscServicesItem(); - item->clear(); - - /* skip the header */ - offset += 8; - - /* get mandatory parts first */ - ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VERSION, item->version); - ok &= item->mServiceIdMap.GetTlv(data, rssize, &offset); - - if (offset != rssize) { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseServices() offset != rssize" << std::endl; -#endif - /* error */ - delete item; - return NULL; - } - - if (!ok) { -#ifdef RSSERIAL_ERROR_DEBUG - std::cerr << "RsDiscSerialiser::deserialiseServices() ok = false" << std::endl; -#endif - delete item; - return NULL; - } - - 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); - 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; -} - -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); - 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; -} - -/*************************************************************************/ - diff --git a/libretroshare/src/serialiser/rsfiletransferitems.cc b/libretroshare/src/serialiser/rsfiletransferitems.cc deleted file mode 100644 index 0caabc2f8..000000000 --- a/libretroshare/src/serialiser/rsfiletransferitems.cc +++ /dev/null @@ -1,797 +0,0 @@ - -/* - * libretroshare/src/serialiser: rsbaseitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2007-2008 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 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 "serialiser/rsbaseserial.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsfiletransferitems.h" - -/*** - * #define RSSERIAL_DEBUG 1 - * #define DEBUG_TRANSFERS 1 -***/ - - -#ifdef DEBUG_TRANSFERS - #include "util/rsprint.h" -#endif - -#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) -{ - 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 ; -} - -/* serialise the data to the buffer */ -bool RsFileTransferChunkMapRequestItem::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) ; - - 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;iclear(); - - /* 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; -} - -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferChunkMapRequestItem(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_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; -} - -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferDataItem(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_DATA != getRsItemSubType(rstype)) - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataItem(): wong subtype!" << std::endl; - return NULL; /* wrong type */ - } - - if (pktsize < rssize) /* check size */ - { - std::cerr << "RsFileTransferSerialiser::deserialise_RsFileTransferDataItem(): size inconsistency!" << std::endl; - return NULL; /* not enough data */ - } - - bool ok = true; - - /* ready to load */ - RsFileTransferDataItem *item = new RsFileTransferDataItem(); - item->clear(); - - /* 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; -} - - -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferDataRequestItem(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_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); - - if(ok) - { - item->compressed_map._map.resize(size) ; - - for(uint32_t i=0;icompressed_map._map[i])); - } - - if (offset != rssize) - { - /* error */ - delete item; - return NULL; - } - - if (!ok) - { - delete item; - return NULL; - } - - return item; -} - -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcRequestItem(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_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; -} -RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferSingleChunkCrcItem(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_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; -} -/*************************************************************************/ diff --git a/libretroshare/src/serialiser/rsgxschannelitems.cc b/libretroshare/src/serialiser/rsgxschannelitems.cc deleted file mode 100644 index bad8a0a98..000000000 --- a/libretroshare/src/serialiser/rsgxschannelitems.cc +++ /dev/null @@ -1,536 +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" - -//#define GXSCHANNEL_DEBUG 1 - - -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; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsChannelGroupItem::clear() -{ - mDescription.clear(); - mImage.TlvClear(); -} - -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; -} - - - -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; -} - - -uint32_t RsGxsChannelSerialiser::sizeGxsChannelGroupItem(RsGxsChannelGroupItem *item) -{ - uint32_t s = 8; // header - - s += GetTlvStringSize(item->mDescription); - s += item->mImage.TlvSize(); - - return s; -} - -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; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsChannelPostItem::clear() -{ - mMsg.clear(); - mAttachment.TlvClear(); - mThumbnail.TlvClear(); -} - -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; -} - - -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; -} - - -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; -} - -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; -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - diff --git a/libretroshare/src/serialiser/rsgxscircleitems.cc b/libretroshare/src/serialiser/rsgxscircleitems.cc deleted file mode 100644 index c9cce891e..000000000 --- a/libretroshare/src/serialiser/rsgxscircleitems.cc +++ /dev/null @@ -1,613 +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 "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" - -//#define CIRCLE_DEBUG 1 - -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; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -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); - - 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; -} - -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) -{ - 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; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsCircleMsgItem::clear() -{ - msg.stuff.clear(); -} - -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; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - diff --git a/libretroshare/src/serialiser/rsgxscommentitems.cc b/libretroshare/src/serialiser/rsgxscommentitems.cc deleted file mode 100644 index 11832701e..000000000 --- a/libretroshare/src/serialiser/rsgxscommentitems.cc +++ /dev/null @@ -1,416 +0,0 @@ -/* - * libretroshare/src/serialiser: rsgxscommentitems.cc - * - * RetroShare C++ Interface. - * - * Copyright 2012-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". - * - */ - -#include - -#include "rsgxscommentitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" - -//#define GXSCOMMENT_DEBUG 1 - - -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; -} - -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; -} - -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; -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - diff --git a/libretroshare/src/serialiser/rsgxsforumitems.cc b/libretroshare/src/serialiser/rsgxsforumitems.cc deleted file mode 100644 index 731584b38..000000000 --- a/libretroshare/src/serialiser/rsgxsforumitems.cc +++ /dev/null @@ -1,401 +0,0 @@ -/* - * libretroshare/src/serialiser: rsgxsforumitems.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 "rsgxsforumitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" - -//#define GXSFORUM_DEBUG 1 - -uint32_t RsGxsForumSerialiser::size(RsItem *item) -{ - RsGxsForumGroupItem* grp_item = NULL; - RsGxsForumMsgItem* op_item = 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; -} - -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) -{ - 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; -} - - -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) -{ - 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; -} - - -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 deleted file mode 100644 index f4bce076d..000000000 --- a/libretroshare/src/serialiser/rsgxsforumitems.h +++ /dev/null @@ -1,95 +0,0 @@ -/* - * libretroshare/src/serialiser: rsgxsforumitems.h - * - * 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 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". - * - */ - -#ifndef RS_GXS_FORUM_ITEMS_H -#define RS_GXS_FORUM_ITEMS_H - -#include - -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" - -#include "rsgxsitems.h" -#include "retroshare/rsgxsforums.h" - -const uint8_t RS_PKT_SUBTYPE_GXSFORUM_GROUP_ITEM = 0x02; -const uint8_t RS_PKT_SUBTYPE_GXSFORUM_MESSAGE_ITEM = 0x03; - -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); - - - RsGxsForumGroup mGroup; -}; - -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); - - RsGxsForumMsg mMsg; -}; - -class RsGxsForumSerialiser : public RsSerialType -{ -public: - - 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); - -}; - -#endif /* RS_GXS_FORUM_ITEMS_H */ diff --git a/libretroshare/src/serialiser/rsgxsiditems.cc b/libretroshare/src/serialiser/rsgxsiditems.cc deleted file mode 100644 index f5019b7f4..000000000 --- a/libretroshare/src/serialiser/rsgxsiditems.cc +++ /dev/null @@ -1,699 +0,0 @@ -/* - * libretroshare/src/serialiser: rsgxsiditems.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 "rsgxsiditems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" -#include "serialiser/rstlvstring.h" -#include "util/rsstring.h" - -#define GXSID_DEBUG 1 - -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 ; -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -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 - 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; -} - - -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; -} - -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; -} - - -bool RsGxsIdGroupItem::fromGxsIdGroup(RsGxsIdGroup &group, bool moveImage) -{ - clear(); - meta = group.mMeta; - mPgpIdHash = group.mPgpIdHash; - mPgpIdSign = group.mPgpIdSign; - mRecognTags = group.mRecognTags; - - 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 RsGxsIdGroupItem::toGxsIdGroup(RsGxsIdGroup &group, bool moveImage) -{ - group.mMeta = meta; - group.mPgpIdHash = mPgpIdHash; - group.mPgpIdSign = mPgpIdSign; - group.mRecognTags = mRecognTags; - - 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 ; -} -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; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -#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/serialiser/rsgxsrecognitems.cc b/libretroshare/src/serialiser/rsgxsrecognitems.cc deleted file mode 100644 index 11317ad3c..000000000 --- a/libretroshare/src/serialiser/rsgxsrecognitems.cc +++ /dev/null @@ -1,609 +0,0 @@ -/* - * libretroshare/src/serialiser: rsgxsrecogitems.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". - * - */ - -#include "serialiser/rsgxsrecognitems.h" -#include "serialiser/rsbaseserial.h" - -/*** -#define RSSERIAL_DEBUG 1 -***/ - -#include - -/*************************************************************************/ - -RsGxsRecognReqItem::~RsGxsRecognReqItem() -{ - return; -} - -void RsGxsRecognReqItem::clear() -{ - issued_at = 0; - period = 0; - tag_class = 0; - tag_type = 0; - - identity.clear(); - nickname.clear(); - comment.clear(); - - sign.TlvClear(); - -} - -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; -} - -/* 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; -} - -void RsGxsRecognTagItem::clear() -{ - valid_from = 0; - valid_to = 0; - - tag_class = 0; - tag_type = 0; - - identity.clear(); - nickname.clear(); - - sign.TlvClear(); -} - -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; -} - -/* 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; -} - -void RsGxsRecognSignerItem::clear() -{ - signing_classes.TlvClear(); - key.TlvClear(); - sign.TlvClear(); -} - -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; -} - -/* 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; - } -} - -/*************************************************************************/ - - - diff --git a/libretroshare/src/serialiser/rsgxsreputationitems.cc b/libretroshare/src/serialiser/rsgxsreputationitems.cc deleted file mode 100644 index 5701cc756..000000000 --- a/libretroshare/src/serialiser/rsgxsreputationitems.cc +++ /dev/null @@ -1,594 +0,0 @@ -/* - * libretroshare/src/serialiser: rsbanlist.cc - * - * RetroShare Serialiser. - * - * Copyright 2011 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 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 -#include "serialiser/rsbaseserial.h" -#include "serialiser/rsgxsreputationitems.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() -{ - mOpinions.clear() ; -} - -void RsGxsReputationUpdateItem::clear() -{ - mOpinions.clear() ; -} - -void RsGxsReputationBannedNodeSetItem::clear() -{ - mKnownIdentities.TlvClear(); -} - -/*************************************************************************/ -/*************************************************************************/ -/*************************************************************************/ - -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; - } -} - -/*************************************************************************/ - - - diff --git a/libretroshare/src/serialiser/rsgxsupdateitems.cc b/libretroshare/src/serialiser/rsgxsupdateitems.cc deleted file mode 100644 index 0074b23c9..000000000 --- a/libretroshare/src/serialiser/rsgxsupdateitems.cc +++ /dev/null @@ -1,694 +0,0 @@ -/* - * libretroshare/src/serialiser: rsgxsupdateitems.h - * - * RetroShare Serialiser. - * - * Copyright 2012 Christopher Evi-Parker - * - * 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 "rsgxsupdateitems.h" -#include "rsbaseserial.h" - -/**********************************************************************************************/ -/* CLEAR */ -/**********************************************************************************************/ - -void RsGxsGrpUpdateItem::clear() -{ - grpUpdateTS = 0; - peerID.clear(); -} - -void RsGxsMsgUpdateItem::clear() -{ - msgUpdateInfos.clear(); - peerID.clear(); -} - -void RsGxsServerMsgUpdateItem::clear() -{ - msgUpdateTS = 0; - grpId.clear(); -} - -void RsGxsServerGrpUpdateItem::clear() -{ - grpUpdateTS = 0; -} - - - -/**********************************************************************************************/ -/* PRINT */ -/**********************************************************************************************/ - -std::ostream& RsGxsMsgUpdateItem::print(std::ostream& out, uint16_t indent) -{ - 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 ; -} - -std::ostream& RsGxsServerMsgUpdateItem::print(std::ostream& out, uint16_t indent) -{ - 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; -} - - -std::ostream& RsGxsServerGrpUpdateItem::print(std::ostream& out, uint16_t indent) -{ - printRsItemBase(out, "RsGxsServerGrpUpdateItem", indent); - uint16_t int_Indent = indent + 2; - out << "grpUpdateTS: " << grpUpdateTS << std::endl; - printIndent(out, int_Indent); - - return out; -} - -/**********************************************************************************************/ -/* SERIALISER */ -/**********************************************************************************************/ - -bool RsGxsNetServiceItem::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 ; -} -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; - } - - return ok; -} - -bool RsGxsServerGrpUpdateItem::serialise(void* data, uint32_t& size) const -{ - uint32_t tlvsize,offset=0; - 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; - } - - return ok; -} -bool RsGxsMsgUpdateItem::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) ; - - 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; -} - -bool RsGxsServerMsgUpdateItem::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 &= 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; -} - -bool RsGxsGrpConfigItem::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 &= 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; -} - - -/**********************************************************************************************/ -/* 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/rsheartbeatitems.cc b/libretroshare/src/serialiser/rsheartbeatitems.cc deleted file mode 100644 index 55f1e844a..000000000 --- a/libretroshare/src/serialiser/rsheartbeatitems.cc +++ /dev/null @@ -1,206 +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". - * - */ - -#include "serialiser/rsbaseserial.h" -#include "serialiser/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; -} - -/*************************************************************************/ - - -void RsHeartbeatItem::clear() -{ -} - -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; -} - - -/*************************************************************************/ diff --git a/libretroshare/src/serialiser/rshistoryitems.cc b/libretroshare/src/serialiser/rshistoryitems.cc deleted file mode 100644 index 2ecbf591b..000000000 --- a/libretroshare/src/serialiser/rshistoryitems.cc +++ /dev/null @@ -1,268 +0,0 @@ -/* - * libretroshare/src/serialiser: rshistoryitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2011 by Thunder. - * - * 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 "serialiser/rshistoryitems.h" -#include "serialiser/rsbaseserial.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsconfigitems.h" - -/*** -#define RSSERIAL_DEBUG 1 -***/ - -#include - -/*************************************************************************/ - -RsHistoryMsgItem::RsHistoryMsgItem() : RsItem(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_HISTORY_CONFIG, RS_PKT_SUBTYPE_DEFAULT) -{ - incoming = false; - sendTime = 0; - recvTime = 0; - msgId = 0; - saveToDisc = true; -} - -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() : RsSerialType(RS_PKT_VERSION1, RS_PKT_CLASS_CONFIG, RS_PKT_TYPE_HISTORY_CONFIG) -{ -} - -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; -} - -/*************************************************************************/ diff --git a/libretroshare/src/serialiser/rsmsgitems.cc b/libretroshare/src/serialiser/rsmsgitems.cc deleted file mode 100644 index 69c1028ee..000000000 --- a/libretroshare/src/serialiser/rsmsgitems.cc +++ /dev/null @@ -1,1200 +0,0 @@ - -/* - * libretroshare/src/serialiser: rsbaseitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2007-2008 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 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 -#include "serialiser/rsbaseserial.h" -#include "serialiser/rsmsgitems.h" -#include "serialiser/rstlvbase.h" - -/*** -#define RSSERIAL_DEBUG 1 -***/ - -#include - -void RsMsgItem::clear() -{ - msgId = 0; - msgFlags = 0; - sendTime = 0; - recvTime = 0; - subject.clear(); - message.clear(); - - rspeerid_msgto.TlvClear(); - rspeerid_msgcc.TlvClear(); - rspeerid_msgbcc.TlvClear(); - - rsgxsid_msgto.TlvClear(); - rsgxsid_msgcc.TlvClear(); - rsgxsid_msgbcc.TlvClear(); - - attachment.TlvClear(); -} - -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; -} - -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); - 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; -} -void RsMsgTags::clear() -{ - msgId = 0; - tagIds.clear(); -} - -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; -} - -void RsMsgGRouterMap::clear() -{ - ongoing_msgs.clear() ; - - return; -} - -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; -} - - -/*************************************************************************/ - diff --git a/libretroshare/src/serialiser/rsnxsitems.cc b/libretroshare/src/serialiser/rsnxsitems.cc deleted file mode 100644 index d17002ca9..000000000 --- a/libretroshare/src/serialiser/rsnxsitems.cc +++ /dev/null @@ -1,1349 +0,0 @@ -#include "rsnxsitems.h" -#include "rsbaseserial.h" -#include "util/rsprint.h" -#include - -/*** - * #define RSSERIAL_DEBUG 1 - ***/ - -const uint8_t RsNxsSyncGrpItem::FLAG_REQUEST = 0x001; -const uint8_t RsNxsSyncGrpItem::FLAG_RESPONSE = 0x002; - -const uint8_t RsNxsSyncMsgItem::FLAG_REQUEST = 0x001; -const uint8_t RsNxsSyncMsgItem::FLAG_RESPONSE = 0x002; - -const uint8_t RsNxsSyncGrpItem::FLAG_USE_SYNC_HASH = 0x0001; -const uint8_t RsNxsSyncMsgItem::FLAG_USE_SYNC_HASH = 0x0001; - -const uint8_t RsNxsSyncMsgReqItem::FLAG_USE_HASHED_GROUP_ID = 0x02; - -/** transaction state **/ -const uint16_t RsNxsTransacItem::FLAG_BEGIN_P1 = 0x0001; -const uint16_t RsNxsTransacItem::FLAG_BEGIN_P2 = 0x0002; -const uint16_t RsNxsTransacItem::FLAG_END_SUCCESS = 0x0004; -const uint16_t RsNxsTransacItem::FLAG_CANCEL = 0x0008; -const uint16_t RsNxsTransacItem::FLAG_END_FAIL_NUM = 0x0010; -const uint16_t RsNxsTransacItem::FLAG_END_FAIL_TIMEOUT = 0x0020; -const uint16_t RsNxsTransacItem::FLAG_END_FAIL_FULL = 0x0040; - - -/** transaction type **/ -const uint16_t RsNxsTransacItem::FLAG_TYPE_GRP_LIST_RESP = 0x0100; -const uint16_t RsNxsTransacItem::FLAG_TYPE_MSG_LIST_RESP = 0x0200; -const uint16_t RsNxsTransacItem::FLAG_TYPE_GRP_LIST_REQ = 0x0400; -const uint16_t RsNxsTransacItem::FLAG_TYPE_MSG_LIST_REQ = 0x0800; -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) -{ -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::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_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); - - default: - { -#ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialise() : data has no type" - << std::endl; -#endif - return NULL; - - } - } -} - - -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; -} - - - - -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) -{ - - 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; -} diff --git a/libretroshare/src/serialiser/rsphotoitems.cc b/libretroshare/src/serialiser/rsphotoitems.cc deleted file mode 100644 index 3ff10cf8e..000000000 --- a/libretroshare/src/serialiser/rsphotoitems.cc +++ /dev/null @@ -1,653 +0,0 @@ -/* - * libretroshare/src/retroshare: rsphoto.h - * - * RetroShare C++ Interface. - * - * Copyright 2012-2012 by Christopher Evi-Parker, 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 - -#include "serialiser/rsphotoitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rstlvbinary.h" -#include "serialiser/rsbaseserial.h" - -#define GXS_PHOTO_SERIAL_DEBUG - - -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; - -} - -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; -} - -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; -} - - - -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; -} - -void RsGxsPhotoAlbumItem::clear() -{ - album.mCaption.clear(); - album.mCategory.clear(); - album.mDescription.clear(); - album.mHashTags.clear(); - album.mOther.clear(); - album.mPhotoPath.clear(); - album.mPhotographer.clear(); - album.mWhen.clear(); - album.mWhere.clear(); - album.mThumbnail.deleteImage(); -} - -void RsGxsPhotoCommentItem::clear() -{ - comment.mComment.clear(); - comment.mCommentFlag = 0; -} - -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; -} - -void RsGxsPhotoPhotoItem::clear() -{ - photo.mCaption.clear(); - photo.mCategory.clear(); - photo.mDescription.clear(); - photo.mHashTags.clear(); - photo.mOther.clear(); - photo.mPhotographer.clear(); - photo.mWhen.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 deleted file mode 100644 index 40fa8b32b..000000000 --- a/libretroshare/src/serialiser/rsphotoitems.h +++ /dev/null @@ -1,112 +0,0 @@ -/* - * libretroshare/src/retroshare: rsphoto.h - * - * RetroShare C++ Interface. - * - * Copyright 2012-2012 by Christopher Evi-Parker, 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". - * - */ - -#ifndef RSPHOTOV2ITEMS_H_ -#define RSPHOTOV2ITEMS_H_ - -#include - -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" - -#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_COMMENT_ITEM = 0x04; - -class RsGxsPhotoAlbumItem : public RsGxsGrpItem -{ - -public: - - RsGxsPhotoAlbumItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_PHOTO, - RS_PKT_SUBTYPE_PHOTO_ITEM) { return;} - virtual ~RsGxsPhotoAlbumItem() { return;} - - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - - RsPhotoAlbum album; -}; - -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); - RsPhotoPhoto photo; -}; - -class RsGxsPhotoCommentItem : public RsGxsMsgItem -{ -public: - - RsGxsPhotoCommentItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_PHOTO, - RS_PKT_SUBTYPE_PHOTO_COMMENT_ITEM) { return; } - virtual ~RsGxsPhotoCommentItem() { return; } - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - RsPhotoComment comment; - - -}; - -class RsGxsPhotoSerialiser : public RsSerialType -{ -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); - -}; - -#endif /* RSPHOTOV2ITEMS_H_ */ diff --git a/libretroshare/src/serialiser/rspluginitems.cc b/libretroshare/src/serialiser/rspluginitems.cc deleted file mode 100644 index d671d1a1c..000000000 --- a/libretroshare/src/serialiser/rspluginitems.cc +++ /dev/null @@ -1,132 +0,0 @@ -#include "rspluginitems.h" - -#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 ; -} - - diff --git a/libretroshare/src/serialiser/rsposteditems.cc b/libretroshare/src/serialiser/rsposteditems.cc deleted file mode 100644 index e5f8a666e..000000000 --- a/libretroshare/src/serialiser/rsposteditems.cc +++ /dev/null @@ -1,389 +0,0 @@ - -/* - * libretroshare/src/gxs: rsopsteditems.cc - * - * RetroShare Serialiser. - * - * Copyright 2012-2013 by Robert Fernie, Christopher Evi-Parker - * - * 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 "serialiser/rsposteditems.h" -#include "rsbaseserial.h" -#include "rstlvbase.h" - - -uint32_t RsGxsPostedSerialiser::size(RsItem *item) -{ -#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); - } -} - -bool RsGxsPostedSerialiser::serialise(RsItem *item, void *data, uint32_t *size) -{ -#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); - } -} - -RsItem* RsGxsPostedSerialiser::deserialise(void *data, uint32_t *size) -{ -#ifdef POSTED_DEBUG - std::cerr << "RsGxsPostedSerialiser::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_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; - } -} - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - -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 deleted file mode 100644 index 6fa08f203..000000000 --- a/libretroshare/src/serialiser/rsposteditems.h +++ /dev/null @@ -1,69 +0,0 @@ -#ifndef RSPOSTEDITEMS_H -#define RSPOSTEDITEMS_H - -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" - -#include "serialiser/rsgxscommentitems.h" - -#include "rsgxsitems.h" -#include "retroshare/rsposted.h" - -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; } - - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - RsPostedGroup mGroup; -}; - -class RsGxsPostedPostItem : public RsGxsMsgItem -{ -public: - RsGxsPostedPostItem() : RsGxsMsgItem(RS_SERVICE_GXS_TYPE_POSTED, - RS_PKT_SUBTYPE_POSTED_POST_ITEM) {return ; } - virtual ~RsGxsPostedPostItem() { return; } - - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - - RsPostedPost mPost; -}; - -class RsGxsPostedSerialiser : public RsGxsCommentSerialiser -{ - -public: - - RsGxsPostedSerialiser() - :RsGxsCommentSerialiser(RS_SERVICE_GXS_TYPE_POSTED) - { return; } - - virtual ~RsGxsPostedSerialiser() { 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 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); -}; - - -#endif // RSPOSTEDITEMS_H diff --git a/libretroshare/src/serialiser/rsrttitems.cc b/libretroshare/src/serialiser/rsrttitems.cc deleted file mode 100644 index 8f5c136e7..000000000 --- a/libretroshare/src/serialiser/rsrttitems.cc +++ /dev/null @@ -1,373 +0,0 @@ - -/* - * libretroshare/src/serialiser: rsrttitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2011-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". - * - */ - -#include "serialiser/rsbaseserial.h" -#include "serialiser/rsrttitems.h" -//#include "serialiser/rstlvbase.h" - -/*** -#define RSSERIAL_DEBUG 1 -***/ - -#include - -/*************************************************************************/ - - -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; -} - - -/*************************************************************************/ - diff --git a/libretroshare/src/serialiser/rsserial.cc b/libretroshare/src/serialiser/rsserial.cc index 549bdc42c..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 @@ -219,6 +222,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 @@ -437,7 +441,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/serialiser/rsserial.h b/libretroshare/src/serialiser/rsserial.h index bb8b84d8c..206f69608 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 "itempriorities.h" - const uint8_t RS_PKT_VERSION1 = 0x01; const uint8_t RS_PKT_VERSION_SERVICE = 0x02; @@ -70,67 +64,8 @@ const uint8_t RS_PKT_CLASS_CONFIG = 0x02; const uint8_t RS_PKT_SUBTYPE_DEFAULT = 0x01; /* if only one subtype */ - -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) = 0; - 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 ;} - - private: - uint32_t type; - RsPeerId peerId; - uint8_t _priority_level ; -}; - - -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 RsItem ; +class RsSerialType ; class RsSerialiser @@ -176,23 +111,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/rsserializer.cc b/libretroshare/src/serialiser/rsserializer.cc new file mode 100644 index 000000000..ea6bdd33c --- /dev/null +++ b/libretroshare/src/serialiser/rsserializer.cc @@ -0,0 +1,240 @@ +/* + * 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" + +#include "util/rsprint.h" +#include "serialiser/rsserializer.h" +#include "serialiser/rstypeserializer.h" + +const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_NONE ( 0x0000 ); +const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_CONFIG ( 0x0001 ); +const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_SIGNATURE ( 0x0002 ); +const SerializationFlags RsGenericSerializer::SERIALIZATION_FLAG_SKIP_HEADER ( 0x0004 ); + +RsItem *RsServiceSerializer::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(getRsItemService(rstype),getRsItemSubType(rstype)) ; + + if(!item) + { + 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 ; + } + + SerializeContext ctx(const_cast(static_cast(data)),*size,mFormat,mFlags); + ctx.mOffset = 8 ; + + item->serial_process(RsGenericSerializer::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 ; +} +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 << (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 ; + } + + SerializeContext ctx(const_cast(static_cast(data)),*size,mFormat,mFlags); + ctx.mOffset = 8 ; + + item->serial_process(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); + + uint32_t tlvsize = this->size(item) ; + + if(tlvsize > *size) + throw std::runtime_error("Cannot serialise: not enough room.") ; + + + if(mFlags & SERIALIZATION_FLAG_SKIP_HEADER) + ctx.mOffset = 0; + else + { + 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(RsGenericSerializer::SERIALIZE,ctx) ; + + if(ctx.mSize != ctx.mOffset) + { + std::cerr << "RsSerializer::serialise(): ERROR. offset does not match expected size!" << std::endl; + return false ; + } + return true ; +} + +uint32_t RsGenericSerializer::size(RsItem *item) +{ + SerializeContext ctx(NULL,0,mFormat,mFlags); + + if(mFlags & SERIALIZATION_FLAG_SKIP_HEADER) + ctx.mOffset = 0; + else + ctx.mOffset = 8 ; // header size + item->serial_process(SIZE_ESTIMATE, ctx) ; + + return ctx.mOffset ; +} + +void RsGenericSerializer::print(RsItem *item) +{ + SerializeContext ctx(NULL,0,mFormat,mFlags); + + std::cerr << "***** RsItem class: \"" << typeid(*item).name() << "\" *****" << std::endl; + item->serial_process(PRINT, ctx) ; + 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 new file mode 100644 index 000000000..2cae93ab7 --- /dev/null +++ b/libretroshare/src/serialiser/rsserializer.h @@ -0,0 +1,299 @@ +/* + * 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 + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// 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) const // mind the "const"! +// { +// 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()) ; +// } +// +// 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 +#include +#include + +#include "retroshare/rsflags.h" +#include "serialiser/rsserial.h" + +class RsItem ; + +#define SERIALIZE_ERROR() std::cerr << __PRETTY_FUNCTION__ << " : " + +// This is the base class for serializers. + +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; +}; + +// This class is only used internally to p3service. It should not be used explicitely otherwise. + +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); +}; + +// Top class for all services and config serializers. + +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 + // 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 + static const SerializationFlags SERIALIZATION_FLAG_SKIP_HEADER ; // 0x0004 + + // The following functions overload RsSerialType. They *should not* need to be further overloaded. + + 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) ; + +protected: + RsGenericSerializer(uint8_t serial_class, + uint8_t serial_type, + SerializationFormat format, + SerializationFlags flags ) + : RsSerialType(RS_PKT_VERSION1,serial_class,serial_type), mFormat(format),mFlags(flags) + {} + + RsGenericSerializer(uint16_t service, + SerializationFormat format, + SerializationFlags flags ) + : RsSerialType(RS_PKT_VERSION_SERVICE,service), mFormat(format),mFlags(flags) + {} + + SerializationFormat mFormat ; + SerializationFlags mFlags ; + +}; + +// Top class for service serializers. Derive your on service serializer from this class and overload creat_item(). + +class RsServiceSerializer: public RsGenericSerializer +{ +public: + RsServiceSerializer(uint16_t service_id, + SerializationFormat format = FORMAT_BINARY, + 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) ; +}; + +// 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: + RsConfigSerializer(uint8_t config_class, + uint8_t config_type, + SerializationFormat format = FORMAT_BINARY, + SerializationFlags flags = 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 /* item_type */, uint8_t /* item_sub_type */) const=0; + + RsItem *deserialise(void *data,uint32_t *size) ; +}; + + + + diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.cc b/libretroshare/src/serialiser/rsserviceinfoitems.cc deleted file mode 100644 index 8efc0eb87..000000000 --- a/libretroshare/src/serialiser/rsserviceinfoitems.cc +++ /dev/null @@ -1,445 +0,0 @@ -/* - * libretroshare/src/serialiser: rsserviceinfoitems.cc - * - * RetroShare Serialiser. - * - * Copyright 2014 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 "serialiser/rsbaseserial.h" -#include "serialiser/rsserviceinfoitems.h" - -/*** -#define RSSERIAL_DEBUG 1 -***/ - -#include - -/*************************************************************************/ -/***** RsServiceInfo ****/ - -template<> -std::ostream &RsTlvParamRef::print(std::ostream &out, uint16_t /*indent*/) const -{ - out << "RsServiceInfo: " << mParam.mServiceType << " name " << mParam.mServiceName; - out << std::endl; - out << "Version(" << mParam.mVersionMajor << "," << mParam.mVersionMinor << ")"; - out << " MinVersion(" << mParam.mMinVersionMajor << "," << mParam.mMinVersionMinor << ")"; - out << std::endl; - return out; -} - -template<> -uint32_t RsTlvParamRef::TlvSize() const -{ - uint32_t s = TLV_HEADER_SIZE; /* header + 4 for size */ - - s += getRawStringSize(mParam.mServiceName); - s += 4; // type. - s += 4; // version. - s += 4; // min version. - return s; -} - -template<> -void RsTlvParamRef::TlvClear() -{ - mParam = RsServiceInfo(); - mParam.mServiceName.clear(); -} - -template<> -bool RsTlvParamRef::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; - - ok &= SetTlvBase(data, tlvend, offset, mParamType, tlvsize); - ok &= setRawString(data, tlvend, offset, mParam.mServiceName); - ok &= setRawUInt32(data, tlvend, offset, mParam.mServiceType); - ok &= setRawUInt16(data, tlvend, offset, mParam.mVersionMajor); - ok &= setRawUInt16(data, tlvend, offset, mParam.mVersionMinor); - ok &= setRawUInt16(data, tlvend, offset, mParam.mMinVersionMajor); - ok &= setRawUInt16(data, tlvend, offset, mParam.mMinVersionMinor); - - if (!ok) - { - std::cerr << "RsTlvParamRef::SetTlv() Failed"; - std::cerr << std::endl; - } - - return ok; -} - -template<> -bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) -{ - if (size < *offset + TLV_HEADER_SIZE) - return false; - - uint16_t tlvtype = 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 (tlvtype != mParamType) /* check type */ - { - return false; - } - - bool ok = true; - - /* ready to load */ - TlvClear(); - - /* skip the header */ - (*offset) += TLV_HEADER_SIZE; - - ok &= getRawString(data, tlvend, offset, mParam.mServiceName); - ok &= getRawUInt32(data, tlvend, offset, &(mParam.mServiceType)); - ok &= getRawUInt16(data, tlvend, offset, &(mParam.mVersionMajor)); - ok &= getRawUInt16(data, tlvend, offset, &(mParam.mVersionMinor)); - ok &= getRawUInt16(data, tlvend, offset, &(mParam.mMinVersionMajor)); - ok &= getRawUInt16(data, tlvend, offset, &(mParam.mMinVersionMinor)); - - return ok; -} - -template class RsTlvParamRef; - -/*************************************************************************/ - -RsServiceInfoListItem::~RsServiceInfoListItem() -{ - return; -} - -void RsServiceInfoListItem::clear() -{ - mServiceInfo.clear(); -} - -std::ostream &RsServiceInfoListItem::print(std::ostream &out, uint16_t indent) -{ - 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; -} - -/* 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; -} - -/* 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; - } -} - -/*************************************************************************/ - - - diff --git a/libretroshare/src/serialiser/rsserviceserialiser.cc b/libretroshare/src/serialiser/rsserviceserialiser.cc deleted file mode 100644 index d99d03de1..000000000 --- a/libretroshare/src/serialiser/rsserviceserialiser.cc +++ /dev/null @@ -1,102 +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 "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 deleted file mode 100644 index 9bc7d728d..000000000 --- a/libretroshare/src/serialiser/rsserviceserialiser.h +++ /dev/null @@ -1,40 +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" - -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/rsstatusitems.cc b/libretroshare/src/serialiser/rsstatusitems.cc deleted file mode 100644 index e39c4f56c..000000000 --- a/libretroshare/src/serialiser/rsstatusitems.cc +++ /dev/null @@ -1,175 +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". - * - */ - -#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); -} - -/*************************************************************************/ 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/serialiser/rstlvbinary.cc b/libretroshare/src/serialiser/rstlvbinary.cc index 5b601a234..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 { @@ -218,5 +246,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..a22269e0f 100644 --- a/libretroshare/src/serialiser/rstlvbinary.h +++ b/libretroshare/src/serialiser/rstlvbinary.h @@ -64,4 +64,25 @@ 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 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; + virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); + + uint8_t *& mDataRef ; + uint32_t & mSizeRef ; + uint16_t tlvtype ; +}; + + 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/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 diff --git a/libretroshare/src/serialiser/rstypeserializer.cc b/libretroshare/src/serialiser/rstypeserializer.cc new file mode 100644 index 000000000..f4cfc0d62 --- /dev/null +++ b/libretroshare/src/serialiser/rstypeserializer.cc @@ -0,0 +1,308 @@ +/* + * 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" +#include "serialiser/rstlvkeys.h" + +#include "util/rsprint.h" + +#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 // +//=================================================================================================// + +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); +} +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); +} +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, 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); +} +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); +} +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 bool& /* member*/) +{ + return 1; +} +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; +} +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 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; +} +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) ; + + 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); + + memcpy(r.first,&data[offset],r.second) ; + 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) ; + offset += 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((uint8_t*)s.first,std::min(50u,s.second)) << ((s.second>50)?"...":"") << std::endl; +} + +//=================================================================================================// +// TlvItems // +//=================================================================================================// + +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 RsTlvItem& s) +{ + return s.SetTlv(data,size,&offset) ; +} + +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 RsTlvItem& s) +{ + // can we call TlvPrint inside this? + + std::cerr << " [" << typeid(s).name() << "] " << n << std::endl; +} diff --git a/libretroshare/src/serialiser/rstypeserializer.h b/libretroshare/src/serialiser/rstypeserializer.h new file mode 100644 index 000000000..333f1a364 --- /dev/null +++ b/libretroshare/src/serialiser/rstypeserializer.h @@ -0,0 +1,441 @@ +/* + * 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" +#include "serialiser/rstlvbase.h" +#include "serialiser/rstlvlist.h" + +#include "retroshare/rsflags.h" +#include "retroshare/rsids.h" + +#include "serialiser/rsserializer.h" + + +class RsTypeSerializer +{ + public: + // This type should be used to pass a parameter to drive the serialisation if needed. + + 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 // + //=================================================================================================// + + template + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,T& member,const std::string& member_name) + { + switch(j) + { + case RsGenericSerializer::SIZE_ESTIMATE: ctx.mOffset += serial_size(member) ; + break ; + + case RsGenericSerializer::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + break ; + + case RsGenericSerializer::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,member) ; + break ; + + case RsGenericSerializer::PRINT: + print_data(member_name,member); + break; + default: + ctx.mOk = false ; + throw std::runtime_error("Unknown serial job") ; + } + } + + //=================================================================================================// + // Generic types + type_id // + //=================================================================================================// + + template + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,uint16_t type_id,T& member,const std::string& member_name) + { + switch(j) + { + case RsGenericSerializer::SIZE_ESTIMATE: ctx.mOffset += serial_size(type_id,member) ; + break ; + + case RsGenericSerializer::DESERIALIZE: ctx.mOk = ctx.mOk && deserialize(ctx.mData,ctx.mSize,ctx.mOffset,type_id,member) ; + break ; + + case RsGenericSerializer::SERIALIZE: ctx.mOk = ctx.mOk && serialize(ctx.mData,ctx.mSize,ctx.mOffset,type_id,member) ; + break ; + + case RsGenericSerializer::PRINT: + print_data(member_name,type_id,member); + break; + default: + ctx.mOk = false ; + throw std::runtime_error("Unknown serial job") ; + } + } + //=================================================================================================// + // std::map // + //=================================================================================================// + + template + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,std::map& v,const std::string& member_name) + { + switch(j) + { + case RsGenericSerializer::SIZE_ESTIMATE: + { + ctx.mOffset += 4 ; + for(typename std::map::iterator it(v.begin());it!=v.end();++it) + { + serial_process(j,ctx,const_cast(it->first),"map::*it->first") ; + serial_process(j,ctx,const_cast(it->second),"map::*it->second") ; + } + } + break ; + + case RsGenericSerializer::DESERIALIZE: + { + uint32_t n=0 ; + serial_process(j,ctx,n,"temporary size"); + + for(uint32_t i=0;ifirst") ; + serial_process(j,ctx,u,"map::*it->second") ; + + v[t] = u ; + } + } + break ; + + case RsGenericSerializer::SERIALIZE: + { + uint32_t n=v.size(); + serial_process(j,ctx,n,"temporary size"); + + for(typename std::map::iterator it(v.begin());it!=v.end();++it) + { + serial_process(j,ctx,const_cast(it->first),"map::*it->first") ; + serial_process(j,ctx,const_cast(it->second),"map::*it->second") ; + } + } + break ; + + case RsGenericSerializer::PRINT: + { + if(v.empty()) + std::cerr << " Empty map \"" << member_name << "\"" << std::endl; + else + std::cerr << " std::map of " << v.size() << " elements: \"" << member_name << "\"" << std::endl; + + for(typename std::map::iterator it(v.begin());it!=v.end();++it) + { + std::cerr << " " ; + + serial_process(j,ctx,const_cast(it->first),"map::*it->first") ; + serial_process(j,ctx,const_cast(it->second),"map::*it->second") ; + } + } + break; + default: + break; + } + } + + //=================================================================================================// + // std::vector // + //=================================================================================================// + + template + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,std::vector& v,const std::string& member_name) + { + switch(j) + { + case RsGenericSerializer::SIZE_ESTIMATE: + { + ctx.mOffset += 4 ; + for(uint32_t i=0;i // + //=================================================================================================// + + 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) ; // the const cast here is a hack to avoid serial_process to instantiate serialise(const T&) + } + 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) ; // the const cast here is a hack to avoid serial_process to instantiate serialise(const T&) + } + 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 // + //=================================================================================================// + + template + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,std::list& v,const std::string& member_name) + { + switch(j) + { + case RsGenericSerializer::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 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.push_back(tmp); + } + } + break ; + + case RsGenericSerializer::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 RsGenericSerializer::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 // + //=================================================================================================// + + template + static void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx,t_RsFlags32& v,const std::string& member_name) + { + switch(j) + { + case RsGenericSerializer::SIZE_ESTIMATE: ctx.mOffset += 4 ; + break ; + + case RsGenericSerializer::DESERIALIZE: + { + uint32_t n=0 ; + deserialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; + v = t_RsFlags32(n) ; + } + break ; + + case RsGenericSerializer::SERIALIZE: + { + uint32_t n=v.toUInt32() ; + serialize(ctx.mData,ctx.mSize,ctx.mOffset,n) ; + } + break ; + + case RsGenericSerializer::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); + 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, 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 */); + + 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 */); +}; + +//=================================================================================================// +// 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; +} + +//=================================================================================================// +// 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; +} diff --git a/libretroshare/src/serialiser/rswikiitems.cc b/libretroshare/src/serialiser/rswikiitems.cc deleted file mode 100644 index fa4b2be72..000000000 --- a/libretroshare/src/serialiser/rswikiitems.cc +++ /dev/null @@ -1,580 +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 "rswikiitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" - -#define GXSID_DEBUG 1 - - -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; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsWikiCollectionItem::clear() -{ - collection.mDescription.clear(); - collection.mCategory.clear(); - collection.mHashTags.clear(); -} - -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; -} - -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; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsWikiSnapshotItem::clear() -{ - snapshot.mPage.clear(); - snapshot.mHashTags.clear(); -} - -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; -} - -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; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsWikiCommentItem::clear() -{ - comment.mComment.clear(); -} - -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; -} - -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; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - diff --git a/libretroshare/src/serialiser/rswikiitems.h b/libretroshare/src/serialiser/rswikiitems.h deleted file mode 100644 index e45eab729..000000000 --- a/libretroshare/src/serialiser/rswikiitems.h +++ /dev/null @@ -1,112 +0,0 @@ -/* - * libretroshare/src/serialiser: rswikiitems.h - * - * 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". - * - */ - -#ifndef RS_WIKI_ITEMS_H -#define RS_WIKI_ITEMS_H - -#include - -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" -//#include "serialiser/rstlvtypes.h" - -#include "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; - -class RsGxsWikiCollectionItem : public RsGxsGrpItem -{ - -public: - - 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); - - - RsWikiCollection collection; -}; - -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); - RsWikiSnapshot snapshot; -}; - -class RsGxsWikiCommentItem : public RsGxsMsgItem -{ -public: - - RsGxsWikiCommentItem(): RsGxsMsgItem(RS_SERVICE_GXS_TYPE_WIKI, - RS_PKT_SUBTYPE_WIKI_COMMENT_ITEM) { return; } - virtual ~RsGxsWikiCommentItem() { return; } - void clear(); - std::ostream &print(std::ostream &out, uint16_t indent = 0); - RsWikiComment comment; - -}; - -class RsGxsWikiSerialiser : public RsSerialType -{ -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); - -}; - -#endif /* RS_WIKI_ITEMS_H */ diff --git a/libretroshare/src/serialiser/rswireitems.cc b/libretroshare/src/serialiser/rswireitems.cc deleted file mode 100644 index 68ec68741..000000000 --- a/libretroshare/src/serialiser/rswireitems.cc +++ /dev/null @@ -1,408 +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 "rswireitems.h" -#include "serialiser/rstlvbase.h" -#include "serialiser/rsbaseserial.h" - -#define WIRE_DEBUG 1 - - -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; -} - - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - - -void RsGxsWireGroupItem::clear() -{ - group.mDescription.clear(); -} - -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; -} - -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; -} - -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; -} - - -/*****************************************************************************************/ -/*****************************************************************************************/ -/*****************************************************************************************/ - diff --git a/libretroshare/src/services/p3banlist.cc b/libretroshare/src/services/p3banlist.cc index 65d56987b..6fd733de5 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 "serialiser/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/p3banlist.h b/libretroshare/src/services/p3banlist.h index 86456d6ae..5a31bd1b1 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/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" 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" 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" 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/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 diff --git a/libretroshare/src/services/p3gxsreputation.cc b/libretroshare/src/services/p3gxsreputation.cc index c60f54f0c..ae4189cfe 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 "serialiser/rsgxsreputationitems.h" -#include "serialiser/rsconfigitems.h" + +#include "rsitems/rsgxsreputationitems.h" +#include "rsitems/rsconfigitems.h" #include @@ -1210,6 +1211,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 +1219,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 +1277,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 +1328,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 890092237..ad45e2298 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" @@ -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(); 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" diff --git a/libretroshare/src/services/p3idservice.cc b/libretroshare/src/services/p3idservice.cc index 78abe7d2b..f267accd0 100644 --- a/libretroshare/src/services/p3idservice.cc +++ b/libretroshare/src/services/p3idservice.cc @@ -27,8 +27,8 @@ #include "services/p3idservice.h" #include "pgp/pgpauxutils.h" -#include "serialiser/rsgxsiditems.h" -#include "serialiser/rsconfigitems.h" +#include "rsitems/rsgxsiditems.h" +#include "rsitems/rsconfigitems.h" #include "retroshare/rsgxsflags.h" #include "util/rsrandom.h" #include "util/rsstring.h" diff --git a/libretroshare/src/services/p3idservice.h b/libretroshare/src/services/p3idservice.h index 91e55fe6d..a88f0ad7e 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 @@ -43,7 +43,7 @@ #include "pqi/authgpg.h" -#include "serialiser/rsgxsrecognitems.h" +#include "rsitems/rsgxsrecognitems.h" class PgpAuxUtils; diff --git a/libretroshare/src/services/p3msgservice.cc b/libretroshare/src/services/p3msgservice.cc index 8781e245b..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" @@ -86,7 +87,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(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 +520,7 @@ RsSerialiser* p3MsgService::setupSerialiser() // this serialiser is used for con { RsSerialiser *rss = new RsSerialiser ; - rss->addSerialType(new RsMsgSerialiser(true)); + rss->addSerialType(new RsMsgSerialiser(RsServiceSerializer::SERIALIZATION_FLAG_CONFIG)); rss->addSerialType(new RsGeneralConfigSerialiser()); return rss; @@ -2024,10 +2025,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(RsServiceSerializer::SERIALIZATION_FLAG_NONE).size(msgitem) ; RsTemporaryMemory msg_serialized_data(msg_serialized_rssize) ; - if(!msgitem->serialise(msg_serialized_data,msg_serialized_rssize,false)) + 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/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" 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; 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" diff --git a/libretroshare/src/services/p3posted.cc b/libretroshare/src/services/p3posted.cc index b231149d5..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 @@ -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; } diff --git a/libretroshare/src/services/p3rtt.cc b/libretroshare/src/services/p3rtt.cc index 250cea007..2fc991227 100644 --- a/libretroshare/src/services/p3rtt.cc +++ b/libretroshare/src/services/p3rtt.cc @@ -33,7 +33,7 @@ #include "rsserver/p3face.h" #include "services/p3rtt.h" -#include "serialiser/rsrttitems.h" +#include "rsitems/rsrttitems.h" #include #include diff --git a/libretroshare/src/services/p3rtt.h b/libretroshare/src/services/p3rtt.h index fdf6ef01c..067feca0c 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" 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/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/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. /** 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" 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" 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..35b250117 100644 --- a/libretroshare/src/turtle/rsturtleitem.cc +++ b/libretroshare/src/turtle/rsturtleitem.cc @@ -6,115 +6,17 @@ #include "rsturtleitem.h" #include "turtleclientservice.h" +#include "serialiser/rstypeserializer.h" + //#define P3TURTLE_DEBUG // -----------------------------------------------------------------------------------// // -------------------------------- Serialization. --------------------------------- // // -----------------------------------------------------------------------------------// // -// -// ---------------------------------- Packet sizes -----------------------------------// -// - -uint32_t RsTurtleStringSearchRequestItem::serial_size() const +RsItem *RsTurtleSerialiser::create_item(uint16_t service,uint8_t item_subtype) 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 ; -} -// -// ---------------------------------- Serialization ----------------------------------// -// -RsItem *RsTurtleSerialiser::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_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,562 +24,194 @@ 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((_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 ; + return NULL ; } -bool RsTurtleStringSearchRequestItem::serialize(void *data,uint32_t& pktsize) const +void RsTurtleStringSearchRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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; + 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") ; } -bool RsTurtleRegExpSearchRequestItem::serialize(void *data,uint32_t& pktsize) const +void RsTurtleRegExpSearchRequestItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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") ; + RsTypeSerializer::serial_process(j,ctx,depth,"depth") ; + RsTypeSerializer::serial_process(j,ctx,expr,"expr") ; } -RsTurtleStringSearchRequestItem::RsTurtleStringSearchRequestItem(void *data,uint32_t pktsize) - : RsTurtleSearchRequestItem(RS_TURTLE_SUBTYPE_STRING_SEARCH_REQUEST) +template<> uint32_t RsTypeSerializer::serial_size(const RsRegularExpression::LinearizedExpression& r) { -#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 ; + uint32_t s = 0 ; - 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); + s += 4 ; // number of strings -#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 + for(unsigned int i=0;i bool RsTypeSerializer::deserialize(const uint8_t data[],uint32_t size,uint32_t& offset,RsRegularExpression::LinearizedExpression& expr) { -#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 ; + uint32_t saved_offset = offset ; - 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) ; + 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 tlvsize = serial_size(); - uint32_t offset = 0; + uint32_t saved_offset = offset ; - if (pktsize < tlvsize) - return false; /* not enough space */ + bool ok = true ; - pktsize = tlvsize; + ok &= setRawUInt32(data,size,&offset,expr._tokens.size()) ; - bool ok = true; + for(unsigned int i=0;i::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 - } + if(!ok) + offset = saved_offset ; + + return ok; +} + +template<> 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; +} + +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") ; + 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; } -RsTurtleSearchResultItem::RsTurtleSearchResultItem(void *data,uint32_t pktsize) - : RsTurtleItem(RS_TURTLE_SUBTYPE_SEARCH_RESULT) +template<> void RsTypeSerializer::print_data(const std::string& n, const TurtleFileInfo& i) { - 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 + std::cerr << " [FileInfo ] " << n << " size=" << i.size << " hash=" << i.hash << ", name=" << i.name << std::endl; } -bool RsTurtleOpenTunnelItem::serialize(void *data,uint32_t& pktsize) const +void RsTurtleOpenTunnelItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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; + 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") ; } -RsTurtleOpenTunnelItem::RsTurtleOpenTunnelItem(void *data,uint32_t pktsize) - : RsTurtleItem(RS_TURTLE_SUBTYPE_OPEN_TUNNEL) +void RsTurtleTunnelOkItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - 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 + RsTypeSerializer::serial_process(j,ctx,tunnel_id ,"tunnel_id") ; + RsTypeSerializer::serial_process(j,ctx,request_id,"request_id") ; } -bool RsTurtleTunnelOkItem::serialize(void *data,uint32_t& pktsize) const +void RsTurtleGenericDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx) { - uint32_t tlvsize = serial_size(); - uint32_t offset = 0; + RsTypeSerializer::serial_process(j,ctx,tunnel_id ,"tunnel_id") ; - if (pktsize < tlvsize) - return false; /* not enough space */ + RsTypeSerializer::TlvMemBlock_proxy prox(data_bytes,data_size) ; - 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 -} - -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 ; + RsTypeSerializer::serial_process(j,ctx,prox,"data bytes") ; } diff --git a/libretroshare/src/turtle/rsturtleitem.h b/libretroshare/src/turtle/rsturtleitem.h index 5b15f7781..78f6155d8 100644 --- a/libretroshare/src/turtle/rsturtleitem.h +++ b/libretroshare/src/turtle/rsturtleitem.h @@ -1,14 +1,20 @@ #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 "serialiser/rsserviceids.h" #include "turtle/turtletypes.h" +#include "serialiser/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 +23,15 @@ 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_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 */ @@ -34,11 +41,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 +52,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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 +82,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; /***********************************************************************************/ @@ -121,34 +117,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; /***********************************************************************************/ @@ -198,8 +188,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 +195,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(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx); }; /***********************************************************************************/ /* Turtle Serialiser class */ /***********************************************************************************/ -class RsTurtleSerialiser: public RsSerialType +class RsTurtleSerialiser: public RsServiceSerializer { public: - RsTurtleSerialiser() : RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_TURTLE) {} + RsTurtleSerialiser() : RsServiceSerializer(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) 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 033d5e046..d9552c662 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 RsServiceSerializer *serializer() { return NULL ; } // These methods are called by the turtle router to add/remove virtual peers when tunnels are created/deleted // 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 98% rename from libretroshare/src/serialiser/rsdsdvitems.h rename to libretroshare/src/unused/rsdsdvitems.h index efafa1f4b..fd03be486 100644 --- a/libretroshare/src/serialiser/rsdsdvitems.h +++ b/libretroshare/src/unused/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/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 { 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/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/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/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 7d083fde5..222412853 100644 --- a/plugins/VOIP/services/rsVOIPItems.h +++ b/plugins/VOIP/services/rsVOIPItems.h @@ -48,8 +48,8 @@ #include -#include "serialiser/rsserviceids.h" -#include "serialiser/rsserial.h" +#include "rsitems/rsserviceids.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 ; }; /**************************************************************************/ 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"