mirror of
https://github.com/RetroShare/RetroShare.git
synced 2025-05-02 14:16:16 -04:00
removed old unused serialization code
This commit is contained in:
csoler
parent
861dc165f7
commit
4bee52c406
15 changed files with 0 additions and 6310 deletions
|
|
@ -67,81 +67,11 @@ void RsGRouterTransactionChunkItem::serial_process(RsGenericSerializer::Serializ
|
|||
std::cerr << " [Binary data] " << ", length=" << chunk_size << " data=" << RsUtil::BinToHex((uint8_t*)chunk_data,std::min(50u,chunk_size)) << ((chunk_size>50)?"...":"") << std::endl;
|
||||
|
||||
}
|
||||
#ifdef TO_REMOVE
|
||||
RsGRouterTransactionChunkItem *RsGRouterSerialiser::deserialise_RsGRouterTransactionChunkItem(void *data, uint32_t tlvsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
if(tlvsize < rssize)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": wrong encoding of item size. Serialisation error!" << std::endl;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
RsGRouterTransactionChunkItem *item = new RsGRouterTransactionChunkItem() ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= getRawUInt64(data, tlvsize, &offset, &item->propagation_id);
|
||||
ok &= getRawUInt32(data, tlvsize, &offset, &item->chunk_start);
|
||||
ok &= getRawUInt32(data, tlvsize, &offset, &item->chunk_size);
|
||||
ok &= getRawUInt32(data, tlvsize, &offset, &item->total_size);
|
||||
|
||||
if(item->chunk_size > rssize || offset > rssize - item->chunk_size) // better than if(item->chunk_size + offset > rssize)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
if( NULL == (item->chunk_data = (uint8_t*)rs_malloc(item->chunk_size)))
|
||||
{
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
memcpy(item->chunk_data,&((uint8_t*)data)[offset],item->chunk_size) ;
|
||||
offset += item->chunk_size ;
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
#endif
|
||||
|
||||
void RsGRouterTransactionAcknItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
|
||||
{
|
||||
RsTypeSerializer::serial_process<uint64_t>(j,ctx,propagation_id,"propagation_id") ;
|
||||
}
|
||||
|
||||
#ifdef TO_REMOVE
|
||||
RsGRouterTransactionAcknItem *RsGRouterSerialiser::deserialise_RsGRouterTransactionAcknItem(void *data, uint32_t tlvsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
RsGRouterTransactionAcknItem *item = new RsGRouterTransactionAcknItem() ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= getRawUInt64(data, tlvsize, &offset, &item->propagation_id);
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
#endif
|
||||
|
||||
void RsGRouterGenericDataItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
|
||||
{
|
||||
RsTypeSerializer::serial_process<uint64_t>(j,ctx,routing_id,"routing_id") ;
|
||||
|
|
@ -174,76 +104,6 @@ void RsGRouterGenericDataItem::serial_process(RsGenericSerializer::SerializeJob
|
|||
}
|
||||
}
|
||||
|
||||
#ifdef TO_REMOVE
|
||||
RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
if(pktsize < rssize)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": wrong encoding of item size. Serialisation error!" << std::endl;
|
||||
return NULL ;
|
||||
}
|
||||
RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem() ;
|
||||
|
||||
ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id);
|
||||
ok &= item->destination_key.deserialise(data, pktsize, offset) ;
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->service_id);
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->data_size);
|
||||
|
||||
if(item->data_size > 0) // This happens when the item data has been deleted from the cache
|
||||
{
|
||||
if(item->data_size > rssize || offset > rssize - item->data_size) // better than if(item->data_size + offset > rssize)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
if( NULL == (item->data_bytes = (uint8_t*)rs_malloc(item->data_size)))
|
||||
{
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
memcpy(item->data_bytes,&((uint8_t*)data)[offset],item->data_size) ;
|
||||
offset += item->data_size ;
|
||||
}
|
||||
else
|
||||
item->data_bytes = NULL ;
|
||||
|
||||
ok &= item->signature.GetTlv(data, pktsize, &offset) ;
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->duplication_factor);
|
||||
|
||||
// make sure the duplication factor is not altered by friends. In the worst case, the item will duplicate a bit more.
|
||||
|
||||
if(item->duplication_factor < 1)
|
||||
{
|
||||
item->duplication_factor = 1 ;
|
||||
std::cerr << "(II) correcting GRouter item duplication factor from 0 to 1, to ensure backward compat." << std::endl;
|
||||
}
|
||||
if(item->duplication_factor > GROUTER_MAX_DUPLICATION_FACTOR)
|
||||
{
|
||||
std::cerr << "(WW) correcting GRouter item duplication factor of " << item->duplication_factor << ". This is very unexpected." << std::endl;
|
||||
item->duplication_factor = GROUTER_MAX_DUPLICATION_FACTOR ;
|
||||
}
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->flags);
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
#endif
|
||||
|
||||
void RsGRouterSignedReceiptItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
|
||||
{
|
||||
RsTypeSerializer::serial_process<uint64_t> (j,ctx,routing_id,"routing_id") ;
|
||||
|
|
@ -258,33 +118,6 @@ void RsGRouterSignedReceiptItem::serial_process(RsGenericSerializer::SerializeJo
|
|||
RsTypeSerializer::serial_process<RsTlvItem>(j,ctx,signature,"signature") ;
|
||||
}
|
||||
|
||||
#ifdef TO_REMOVE
|
||||
RsGRouterSignedReceiptItem *RsGRouterSerialiser::deserialise_RsGRouterSignedReceiptItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
RsGRouterSignedReceiptItem *item = new RsGRouterSignedReceiptItem() ;
|
||||
|
||||
ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id);
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->flags);
|
||||
ok &= item->destination_key.deserialise(data, pktsize, offset);
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->service_id);
|
||||
ok &= item->data_hash.deserialise(data, pktsize, offset);
|
||||
ok &= item->signature.GetTlv(data, pktsize, &offset); // signature
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
#endif
|
||||
|
||||
void RsGRouterRoutingInfoItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
|
||||
{
|
||||
RsTypeSerializer::serial_process (j,ctx,peerId,"peerId") ;
|
||||
|
|
@ -352,99 +185,11 @@ void RsGRouterRoutingInfoItem::serial_process(RsGenericSerializer::SerializeJob
|
|||
}
|
||||
}
|
||||
|
||||
#ifdef TO_REMOVE
|
||||
RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
RsGRouterRoutingInfoItem *item = new RsGRouterRoutingInfoItem() ;
|
||||
|
||||
RsPeerId peer_id ;
|
||||
ok &= peer_id.deserialise(data, pktsize, offset) ;
|
||||
item->PeerId(peer_id) ;
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->data_status);
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->tunnel_status);
|
||||
ok &= getRawTimeT(data, pktsize, &offset, item->received_time_TS);
|
||||
ok &= getRawTimeT(data, pktsize, &offset, item->last_sent_TS);
|
||||
|
||||
ok &= getRawTimeT(data, pktsize, &offset, item->last_tunnel_request_TS);
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->sending_attempts);
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->client_id);
|
||||
ok &= item->item_hash.deserialise(data, pktsize, offset) ;
|
||||
ok &= item->tunnel_hash.deserialise(data, pktsize, offset) ;
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->routing_flags) ;
|
||||
|
||||
ok &= item->incoming_routes.GetTlv(data,pktsize,&offset) ;
|
||||
|
||||
item->data_item = deserialise_RsGRouterGenericDataItem(&((uint8_t*)data)[offset],pktsize - offset) ;
|
||||
if(item->data_item != NULL)
|
||||
offset += item->data_item->serial_size() ;
|
||||
else
|
||||
ok = false ;
|
||||
|
||||
// Receipt item is optional.
|
||||
|
||||
if (offset < pktsize)
|
||||
{ //
|
||||
item->receipt_item = deserialise_RsGRouterSignedReceiptItem(&((uint8_t*)data)[offset],pktsize - offset);
|
||||
if (item->receipt_item != NULL)
|
||||
offset += item->receipt_item->serial_size();
|
||||
else //
|
||||
ok = false;
|
||||
}
|
||||
else //
|
||||
item->receipt_item = NULL;
|
||||
|
||||
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
#endif
|
||||
|
||||
void RsGRouterMatrixFriendListItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
|
||||
{
|
||||
RsTypeSerializer::serial_process(j,ctx,reverse_friend_indices,"reverse_friend_indices") ;
|
||||
}
|
||||
|
||||
#ifdef TO_REMOVE
|
||||
RsGRouterMatrixFriendListItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
RsGRouterMatrixFriendListItem *item = new RsGRouterMatrixFriendListItem() ;
|
||||
|
||||
uint32_t nb_friends = 0 ;
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &nb_friends); // file hash
|
||||
|
||||
item->reverse_friend_indices.resize(nb_friends) ;
|
||||
|
||||
for(uint32_t i=0;ok && i<nb_friends;++i)
|
||||
ok &= item->reverse_friend_indices[i].deserialise(data, pktsize, offset) ;
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
#endif
|
||||
|
||||
void RsGRouterMatrixTrackItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
|
||||
{
|
||||
RsTypeSerializer::serial_process(j,ctx,provider_id,"provider_id") ;
|
||||
|
|
@ -452,30 +197,6 @@ void RsGRouterMatrixTrackItem::serial_process(RsGenericSerializer::SerializeJob
|
|||
RsTypeSerializer::serial_process<time_t>(j,ctx,time_stamp,"time_stamp") ;
|
||||
}
|
||||
|
||||
#ifdef TO_REMOVE
|
||||
RsGRouterMatrixTrackItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixTrackItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
RsGRouterMatrixTrackItem *item = new RsGRouterMatrixTrackItem() ;
|
||||
|
||||
ok &= item->provider_id.deserialise(data, pktsize, offset) ;
|
||||
ok &= item->message_id.deserialise(data,pktsize,offset) ;
|
||||
ok &= getRawTimeT(data, pktsize, &offset, item->time_stamp) ;
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
#endif
|
||||
|
||||
void RsGRouterMatrixCluesItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
|
||||
{
|
||||
RsTypeSerializer::serial_process(j,ctx,destination_key,"destination_key") ;
|
||||
|
|
@ -489,44 +210,6 @@ template<> void RsTypeSerializer::serial_process(RsGenericSerializer::SerializeJ
|
|||
RsTypeSerializer::serial_process<time_t> (j,ctx,s.time_stamp,name+":time_stamp") ;
|
||||
}
|
||||
|
||||
#ifdef TO_REMOVE
|
||||
RsGRouterMatrixCluesItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
RsGRouterMatrixCluesItem *item = new RsGRouterMatrixCluesItem() ;
|
||||
|
||||
ok &= item->destination_key.deserialise(data,pktsize,offset) ;
|
||||
|
||||
uint32_t nb_clues = 0 ;
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &nb_clues);
|
||||
|
||||
item->clues.clear() ;
|
||||
|
||||
for(uint32_t j=0;j<nb_clues;++j)
|
||||
{
|
||||
RoutingMatrixHitEntry HitE ;
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &HitE.friend_id);
|
||||
ok &= getRawUFloat32(data, pktsize, &offset, HitE.weight);
|
||||
ok &= getRawTimeT(data, pktsize, &offset, HitE.time_stamp);
|
||||
|
||||
item->clues.push_back(HitE) ;
|
||||
}
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
#endif
|
||||
|
||||
RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const
|
||||
{
|
||||
RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem ;
|
||||
|
|
@ -565,508 +248,3 @@ RsGRouterSignedReceiptItem *RsGRouterSignedReceiptItem::duplicate() const
|
|||
return item ;
|
||||
}
|
||||
|
||||
#ifdef TO_REMOVE
|
||||
uint32_t RsGRouterGenericDataItem::serial_size() const
|
||||
{
|
||||
uint32_t s = 8 ; // header
|
||||
s += sizeof(GRouterMsgPropagationId) ; // routing id
|
||||
s += destination_key.serial_size() ; // destination_key
|
||||
s += 4 ; // data_size
|
||||
s += 4 ; // service id
|
||||
s += data_size ; // data
|
||||
s += signature.TlvSize() ; // signature
|
||||
s += 4 ; // duplication_factor
|
||||
s += 4 ; // flags
|
||||
|
||||
return s ;
|
||||
}
|
||||
uint32_t RsGRouterGenericDataItem::signed_data_size() const
|
||||
{
|
||||
uint32_t s = 0 ; // no header
|
||||
s += sizeof(GRouterMsgPropagationId) ; // routing id
|
||||
s += destination_key.serial_size() ; // destination_key
|
||||
s += 4 ; // data_size
|
||||
s += 4 ; // service id
|
||||
s += data_size ; // data
|
||||
|
||||
return s ;
|
||||
}
|
||||
uint32_t RsGRouterSignedReceiptItem::serial_size() const
|
||||
{
|
||||
uint32_t s = 8 ; // header
|
||||
s += sizeof(GRouterMsgPropagationId) ; // routing id
|
||||
s += destination_key.serial_size() ; // destination_key
|
||||
s += data_hash.serial_size() ;
|
||||
s += 4 ; // state
|
||||
s += 4 ; // service_id
|
||||
s += signature.TlvSize() ; // signature
|
||||
|
||||
return s ;
|
||||
}
|
||||
uint32_t RsGRouterSignedReceiptItem::signed_data_size() const
|
||||
{
|
||||
uint32_t s = 0 ; // no header
|
||||
s += sizeof(GRouterMsgPropagationId) ; // routing id
|
||||
s += destination_key.serial_size() ; // destination_key
|
||||
s += data_hash.serial_size() ;
|
||||
s += 4 ; // service_id
|
||||
s += 4 ; // state
|
||||
|
||||
return s ;
|
||||
}
|
||||
uint32_t RsGRouterTransactionChunkItem::serial_size() const
|
||||
{
|
||||
uint32_t s = 8 ; // header
|
||||
s += sizeof(GRouterMsgPropagationId) ; // routing id
|
||||
s += 4 ; // chunk_start
|
||||
s += 4 ; // chunk_size
|
||||
s += 4 ; // total_size
|
||||
s += chunk_size ; // data
|
||||
|
||||
return s;
|
||||
}
|
||||
uint32_t RsGRouterTransactionAcknItem::serial_size() const
|
||||
{
|
||||
uint32_t s = 8 ; // header
|
||||
s += sizeof(GRouterMsgPropagationId) ; // routing id
|
||||
|
||||
return s;
|
||||
}
|
||||
bool RsGRouterTransactionChunkItem::serialise(void *data,uint32_t& size) const
|
||||
{
|
||||
uint32_t tlvsize,offset=0;
|
||||
bool ok = true;
|
||||
|
||||
if(!serialise_header(data,size,tlvsize,offset))
|
||||
return false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt64(data, tlvsize, &offset, propagation_id);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, chunk_start);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, chunk_size);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, total_size);
|
||||
|
||||
memcpy(&((uint8_t*)data)[offset],chunk_data,chunk_size) ;
|
||||
offset += chunk_size ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
bool RsGRouterGenericDataItem::serialise(void *data,uint32_t& size) const
|
||||
{
|
||||
uint32_t tlvsize,offset=0;
|
||||
bool ok = true;
|
||||
|
||||
if(!serialise_header(data,size,tlvsize,offset))
|
||||
return false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt64(data, tlvsize, &offset, routing_id);
|
||||
ok &= destination_key.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, service_id);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, data_size);
|
||||
|
||||
memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ;
|
||||
offset += data_size ;
|
||||
|
||||
ok &= signature.SetTlv(data, tlvsize, &offset) ;
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, duplication_factor) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, flags) ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
bool RsGRouterTransactionAcknItem::serialise(void *data,uint32_t& size) const
|
||||
{
|
||||
uint32_t tlvsize,offset=0;
|
||||
bool ok = true;
|
||||
|
||||
if(!serialise_header(data,size,tlvsize,offset))
|
||||
return false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt64(data, tlvsize, &offset, propagation_id);
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
bool RsGRouterGenericDataItem::serialise_signed_data(void *data,uint32_t size) const
|
||||
{
|
||||
bool ok = true;
|
||||
|
||||
uint32_t offset = 0;
|
||||
uint32_t tlvsize = signed_data_size() ;
|
||||
|
||||
if(tlvsize > size)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterReceiptItem::serialisedata() size error! Not enough size in supplied container." << std::endl;
|
||||
}
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt64(data, tlvsize, &offset, routing_id);
|
||||
ok &= destination_key.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, service_id);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, data_size);
|
||||
|
||||
memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ;
|
||||
offset += data_size ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
bool RsGRouterSignedReceiptItem::serialise(void *data,uint32_t& size) const
|
||||
{
|
||||
uint32_t tlvsize,offset=0;
|
||||
bool ok = true;
|
||||
|
||||
if(!serialise_header(data,size,tlvsize,offset))
|
||||
return false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt64(data, tlvsize, &offset, routing_id);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, flags);
|
||||
ok &= destination_key.serialise(data,tlvsize,offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, service_id);
|
||||
ok &= data_hash.serialise(data,tlvsize,offset) ;
|
||||
ok &= signature.SetTlv(data,tlvsize,&offset) ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterReceiptItem::serialisedata() size error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
bool RsGRouterSignedReceiptItem::serialise_signed_data(void *data,uint32_t size) const
|
||||
{
|
||||
bool ok = true;
|
||||
|
||||
uint32_t offset=0;
|
||||
uint32_t tlvsize = signed_data_size() ;
|
||||
|
||||
if(tlvsize > size)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterReceiptItem::serialisedata() size error! Not enough size in supplied container." << std::endl;
|
||||
}
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt64(data, tlvsize, &offset, routing_id);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, flags);
|
||||
ok &= destination_key.serialise(data,tlvsize,offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, service_id);
|
||||
ok &= data_hash.serialise(data,tlvsize,offset) ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterReceiptItem::serialisedata() size error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
/* serialise the data to the buffer */
|
||||
uint32_t RsGRouterMatrixCluesItem::serial_size() const
|
||||
{
|
||||
uint32_t s = 8 ; // header
|
||||
|
||||
s += destination_key.serial_size() ; // Key size
|
||||
s += 4 ; // list<RoutingMatrixHitEntry>::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<reverse_friend_indices.size();++i)
|
||||
ok &= reverse_friend_indices[i].serialise(data,tlvsize,offset) ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsGRouterMatrixFriendListItem::serialisedata() size error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
bool RsGRouterMatrixCluesItem::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 &= destination_key.serialise(data,tlvsize,offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, clues.size());
|
||||
|
||||
for(std::list<RoutingMatrixHitEntry>::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<RoutingMatrixHitEntry>::const_iterator it(clues.begin());it!=clues.end();++it)
|
||||
o << " " << (*it).friend_id << " " << (*it).time_stamp << " " << (*it).weight << std::endl;
|
||||
|
||||
return o ;
|
||||
}
|
||||
std::ostream& RsGRouterTransactionChunkItem::print(std::ostream& o, uint16_t)
|
||||
{
|
||||
o << "RsGRouterTransactionChunkItem:" << std::endl ;
|
||||
o << " total_size: " << total_size << std::endl;
|
||||
o << " chunk_size: " << chunk_size << std::endl;
|
||||
o << " chunk_start: " << chunk_start << std::endl;
|
||||
|
||||
return o ;
|
||||
}
|
||||
std::ostream& RsGRouterTransactionAcknItem::print(std::ostream& o, uint16_t)
|
||||
{
|
||||
o << "RsGRouterTransactionAcknItem:" << std::endl ;
|
||||
o << " routing id: " << propagation_id << std::endl;
|
||||
|
||||
return o ;
|
||||
}
|
||||
std::ostream& RsGRouterMatrixFriendListItem::print(std::ostream& o, uint16_t)
|
||||
{
|
||||
o << "RsGRouterMatrixCluesItem:" << std::endl ;
|
||||
o << " friends: " << reverse_friend_indices.size() << std::endl;
|
||||
|
||||
return o ;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -2205,26 +2205,6 @@ Sha1CheckSum p3GRouter::makeTunnelHash(const RsGxsId& destination,const GRouterS
|
|||
|
||||
return RsDirUtil::sha1sum(bytes,20) ;
|
||||
}
|
||||
#ifdef TO_REMOVE
|
||||
bool p3GRouter::locked_getGxsOwnIdAndClientIdFromHash(const TurtleFileHash& sum,RsGxsId& gxs_id,GRouterServiceId& client_id)
|
||||
{
|
||||
assert( gxs_id.SIZE_IN_BYTES == 16) ;
|
||||
assert(Sha1CheckSum::SIZE_IN_BYTES == 20) ;
|
||||
|
||||
//gxs_id = RsGxsId(sum.toByteArray());// takes the first 16 bytes
|
||||
//client_id = sum.toByteArray()[19] + (sum.toByteArray()[18] << 8) ;
|
||||
|
||||
std::map<Sha1CheckSum, GRouterPublishedKeyInfo>::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<RsItem*>& items)
|
||||
{
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue