Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-06-28 08:07:31 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

moved signature validation and encryption one level up into p3IdService. Added timestamp for GXS identities and auto-removal after 7 days. Updated display in IdDialog

Browse source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@8015 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
csoler 2015-03-14 14:33:23 +00:00
parent b46c3b4852
commit 48ea291d95
24 changed files with 944 additions and 415 deletions
Download patch file Download diff file Expand all files Collapse all files

5
libretroshare/src/serialiser/rsgxscircleitems.cc
View file

@ -44,8 +44,9 @@ uint32_t RsGxsCircleSerialiser::size(RsItem *item)
else if((snap_item = dynamic_cast<RsGxsCircleMsgItem*>(item)) != NULL)
{
return sizeGxsCircleMsgItem(snap_item);
}
return NULL;
}
else
return 0 ;
}
bool RsGxsCircleSerialiser::serialise(RsItem *item, void *data, uint32_t *size)

407
libretroshare/src/serialiser/rsgxsiditems.cc
View file

@ -33,102 +33,61 @@
#define GXSID_DEBUG 1
uint32_t RsGxsIdSerialiser::size(RsItem *item)
{
RsGxsIdGroupItem* grp_item = NULL;
#if 0
RsGxsIdOpinionItem* op_item = NULL;
RsGxsIdCommentItem* com_item = NULL;
#endif
if((grp_item = dynamic_cast<RsGxsIdGroupItem*>(item)) != NULL)
{
return sizeGxsIdGroupItem(grp_item);
}
#if 0
else if((op_item = dynamic_cast<RsGxsIdOpinionItem*>(item)) != NULL)
{
return sizeGxsIdOpinionItem(op_item);
}
else if((com_item = dynamic_cast<RsGxsIdCommentItem*>(item)) != NULL)
{
return sizeGxsIdCommentItem(com_item);
}
#endif
std::cerr << "RsGxsIdSerialiser::size() ERROR invalid item" << std::endl;
return 0;
}
bool RsGxsIdSerialiser::serialise(RsItem *item, void *data, uint32_t *size)
{
RsGxsIdGroupItem* grp_item = NULL;
#if 0
RsGxsIdOpinionItem* op_item = NULL;
RsGxsIdCommentItem* com_item = NULL;
#endif
if((grp_item = dynamic_cast<RsGxsIdGroupItem*>(item)) != NULL)
{
return serialiseGxsIdGroupItem(grp_item, data, size);
}
#if 0
else if((op_item = dynamic_cast<RsGxsIdOpinionItem*>(item)) != NULL)
{
return serialiseGxsIdOpinionItem(op_item, data, size);
}
else if((com_item = dynamic_cast<RsGxsIdCommentItem*>(item)) != NULL)
{
return serialiseGxsIdCommentItem(com_item, data, size);
}
#endif
std::cerr << "RsGxsIdSerialiser::serialise() ERROR invalid item" << std::endl;
return false;
}
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 deserialiseGxsIdGroupItem(data, size);
break;
/* 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 deserialiseGxsIdOpinionItem(data, size);
break;
case RS_PKT_SUBTYPE_GXSID_COMMENT_ITEM:
return deserialiseGxsIdCommentItem(data, size);
break;
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:
default:
#ifdef GXSID_DEBUG
std::cerr << "RsGxsIdSerialiser::deserialise(): unknown subtype";
std::cerr << std::endl;
std::cerr << "RsGxsIdSerialiser::deserialise(): unknown subtype";
std::cerr << std::endl;
#endif
break;
}
return NULL;
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();
@ -137,7 +96,27 @@ void RsGxsIdGroupItem::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) ;
return s;
}
std::ostream& RsGxsIdLocalInfoItem::print(std::ostream& out, uint16_t indent)
{
printRsItemBase(out, "RsGxsIdLocalInfoItem", indent);
uint16_t int_Indent = indent + 2;
// convert from binary to hex.
for(std::map<RsGxsId,time_t>::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);
@ -167,71 +146,88 @@ std::ostream& RsGxsIdGroupItem::print(std::ostream& out, uint16_t indent)
}
uint32_t RsGxsIdSerialiser::sizeGxsIdGroupItem(RsGxsIdGroupItem *item)
uint32_t RsGxsIdGroupItem::serial_size()
{
uint32_t s = 8; // header
s += Sha1CheckSum::SIZE_IN_BYTES;
s += GetTlvStringSize(item->mPgpIdSign);
s += GetTlvStringSize(mPgpIdSign);
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->mRecognTags);
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, mRecognTags);
s += set.TlvSize();
s += item->mImage.TlvSize() ;
s += mImage.TlvSize() ;
return s;
}
bool RsGxsIdSerialiser::serialiseGxsIdGroupItem(RsGxsIdGroupItem *item, void *data, uint32_t *size)
bool RsGxsIdLocalInfoItem::serialise(void *data, uint32_t& size)
{
uint32_t tlvsize = sizeGxsIdGroupItem(item);
uint32_t offset = 0;
if(*size < tlvsize)
{
#ifdef GXSID_DEBUG
std::cerr << "RsGxsIdSerialiser::serialiseGxsIdGroupItem() 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;
/* GxsIdGroupItem */
ok &= item->mPgpIdHash.serialise(data, tlvsize, offset);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_SIGN, item->mPgpIdSign);
uint32_t tlvsize,offset=0;
bool ok = true;
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->mRecognTags);
ok &= set.SetTlv(data, tlvsize, &offset);
if(!serialise_header(data,size,tlvsize,offset))
return false ;
ok &= item->mImage.SetTlv(data,tlvsize,&offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, mTimeStamps.size()) ;
if(offset != tlvsize)
{
for(std::map<RsGxsId,time_t>::const_iterator it = mTimeStamps.begin();it!=mTimeStamps.end();++it)
{
ok &= it->first.serialise(data,tlvsize,offset) ;
ok &= setRawTimeT(data,tlvsize,&offset,it->second) ;
}
if(offset != tlvsize)
{
#ifdef GXSID_DEBUG
std::cerr << "RsGxsIdSerialiser::serialiseGxsIdGroupItem() FAIL Size Error! " << std::endl;
std::cerr << "RsGxsIdSerialiser::serialiseGxsIdGroupItem() FAIL Size Error! " << std::endl;
#endif
ok = false;
}
ok = false;
}
#ifdef GXSID_DEBUG
if (!ok)
{
std::cerr << "RsGxsIdSerialiser::serialiseGxsIdgroupItem() NOK" << std::endl;
}
if (!ok)
{
std::cerr << "RsGxsIdSerialiser::serialiseGxsIdgroupItem() NOK" << std::endl;
}
#endif
return ok;
}
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)
@ -273,8 +269,74 @@ bool RsGxsIdGroupItem::toGxsIdGroup(RsGxsIdGroup &group, bool moveImage)
}
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);
RsGxsIdGroupItem* RsGxsIdSerialiser::deserialiseGxsIdGroupItem(void *data, uint32_t *size)
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);
@ -285,7 +347,7 @@ RsGxsIdGroupItem* RsGxsIdSerialiser::deserialiseGxsIdGroupItem(void *data, uint3
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_GXS_TYPE_GXSID != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_GXSID_GROUP_ITEM != getRsItemSubType(rstype)))
(RS_PKT_SUBTYPE_GXSID_LOCAL_INFO_ITEM != getRsItemSubType(rstype)))
{
#ifdef GXSID_DEBUG
std::cerr << "RsGxsIdSerialiser::deserialiseGxsIdGroupItem() FAIL wrong type" << std::endl;
@ -306,19 +368,23 @@ RsGxsIdGroupItem* RsGxsIdSerialiser::deserialiseGxsIdGroupItem(void *data, uint3
bool ok = true;
RsGxsIdGroupItem* item = new RsGxsIdGroupItem();
RsGxsIdLocalInfoItem* item = new RsGxsIdLocalInfoItem();
/* 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);
uint32_t n=0 ;
ok &= getRawUInt32(data, rssize, &offset, &n) ;
// image is optional,so that we can continue reading old items.
if(offset < rssize)
ok &= item->mImage.GetTlv(data,rssize,&offset) ;
for(int i=0;ok && i<n;++i)
{
RsGxsId gxsid ;
time_t TS ;
ok &= gxsid.deserialise(data,rssize,offset) ;
ok &= getRawTimeT(data,rssize,&offset,TS) ;
item->mTimeStamps[gxsid] = TS ;
}
if (offset != rssize)
{
@ -374,7 +440,7 @@ std::ostream& RsGxsIdOpinionItem::print(std::ostream& out, uint16_t indent)
}
uint32_t RsGxsIdSerialiser::sizeGxsIdOpinionItem(RsGxsIdOpinionItem *item)
uint32_t RsGxsIdOpinionItem::serial_size()
{
const RsGxsIdOpinion& opinion = item->opinion;
@ -387,29 +453,13 @@ uint32_t RsGxsIdSerialiser::sizeGxsIdOpinionItem(RsGxsIdOpinionItem *item)
return s;
}
bool RsGxsIdSerialiser::serialiseGxsIdOpinionItem(RsGxsIdOpinionItem *item, void *data, uint32_t *size)
bool RsGxsIdOpinionItem::serialise(void *data, uint32_t *size)
{
uint32_t tlvsize = sizeGxsIdOpinionItem(item);
uint32_t offset = 0;
if(*size < tlvsize)
{
#ifdef GXSID_DEBUG
std::cerr << "RsGxsIdSerialiser::serialiseGxsIdOpinionItem()" << std::endl;
#endif
return false;
}
*size = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
/* skip the header */
offset += 8;
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);
@ -434,7 +484,7 @@ bool RsGxsIdSerialiser::serialiseGxsIdOpinionItem(RsGxsIdOpinionItem *item, void
return ok;
}
RsGxsIdOpinionItem* RsGxsIdSerialiser::deserialiseGxsIdOpinionItem(void *data, uint32_t *size)
RsGxsIdOpinionItem* RsGxsIdSerialiser::deserialise_GxsIdOpinionItem(void *data, uint32_t *size)
{
/* get the type and size */
@ -521,7 +571,7 @@ std::ostream& RsGxsIdCommentItem::print(std::ostream& out, uint16_t indent)
}
uint32_t RsGxsIdSerialiser::sizeGxsIdCommentItem(RsGxsIdCommentItem *item)
uint32_t RsGxsIdCommentItem::serial_size()
{
const RsGxsIdComment& comment = item->comment;
@ -532,28 +582,13 @@ uint32_t RsGxsIdSerialiser::sizeGxsIdCommentItem(RsGxsIdCommentItem *item)
return s;
}
bool RsGxsIdSerialiser::serialiseGxsIdCommentItem(RsGxsIdCommentItem *item, void *data, uint32_t *size)
bool RsGxsIdCommentItem::serialise(void *data, uint32_t *size)
{
uint32_t tlvsize = sizeGxsIdCommentItem(item);
uint32_t offset = 0;
if(*size < tlvsize)
{
#ifdef GXSID_DEBUG
std::cerr << "RsGxsIdSerialiser::serialiseGxsIdCommentItem() Not enough space" << std::endl;
#endif
return false;
}
*size = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
/* skip the header */
offset += 8;
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);
@ -576,7 +611,7 @@ bool RsGxsIdSerialiser::serialiseGxsIdCommentItem(RsGxsIdCommentItem *item, void
return ok;
}
RsGxsIdCommentItem* RsGxsIdSerialiser::deserialiseGxsIdCommentItem(void *data, uint32_t *size)
RsGxsIdCommentItem* RsGxsIdSerialiser::deserialise_GxsIdCommentItem(void *data, uint32_t *size)
{
/* get the type and size */

97
libretroshare/src/serialiser/rsgxsiditems.h
View file

@ -36,21 +36,37 @@
//const uint8_t RS_PKT_SUBTYPE_GXSID_GROUP_ITEM_deprecated = 0x02;
const uint8_t RS_PKT_SUBTYPE_GXSID_GROUP_ITEM = 0x02;
const uint8_t RS_PKT_SUBTYPE_GXSID_OPINION_ITEM = 0x03;
const uint8_t RS_PKT_SUBTYPE_GXSID_COMMENT_ITEM = 0x04;
const uint8_t RS_PKT_SUBTYPE_GXSID_GROUP_ITEM = 0x02;
const uint8_t RS_PKT_SUBTYPE_GXSID_OPINION_ITEM = 0x03;
const uint8_t RS_PKT_SUBTYPE_GXSID_COMMENT_ITEM = 0x04;
const uint8_t RS_PKT_SUBTYPE_GXSID_LOCAL_INFO_ITEM = 0x05;
class RsGxsIdGroupItem : public RsGxsGrpItem
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
{
public:
RsGxsIdGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_GXSID,
RS_PKT_SUBTYPE_GXSID_GROUP_ITEM) { return;}
virtual ~RsGxsIdGroupItem() { return;}
RsGxsIdGroupItem(): RsGxsIdItem(RS_PKT_SUBTYPE_GXSID_GROUP_ITEM) {}
virtual ~RsGxsIdGroupItem() {}
void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
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);
@ -66,6 +82,22 @@ public:
// Avatar
RsTlvImage mImage ;
};
class RsGxsIdLocalInfoItem : public RsGxsIdItem
{
public:
RsGxsIdLocalInfoItem(): RsGxsIdItem(RS_PKT_SUBTYPE_GXSID_LOCAL_INFO_ITEM) {}
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() ;
std::map<RsGxsId,time_t> mTimeStamps ;
};
#if 0
class RsGxsIdOpinionItem : public RsGxsMsgItem
@ -76,7 +108,10 @@ public:
RS_PKT_SUBTYPE_GXSID_OPINION_ITEM) {return; }
virtual ~RsGxsIdOpinionItem() { return;}
void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
virtual bool serialise(void *data,uint32_t& size) = 0 ;
virtual uint32_t serial_size() = 0 ;
std::ostream &print(std::ostream &out, uint16_t indent = 0);
RsGxsIdOpinion opinion;
};
@ -88,6 +123,9 @@ public:
RS_PKT_SUBTYPE_GXSID_COMMENT_ITEM) { return; }
virtual ~RsGxsIdCommentItem() { return; }
void clear();
virtual bool serialise(void *data,uint32_t& size) = 0 ;
virtual uint32_t serial_size() = 0 ;
std::ostream &print(std::ostream &out, uint16_t indent = 0);
RsGxsIdComment comment;
@ -97,33 +135,26 @@ public:
class RsGxsIdSerialiser : public RsSerialType
{
public:
RsGxsIdSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_GXSID) {}
virtual ~RsGxsIdSerialiser() {}
RsGxsIdSerialiser()
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_GXSID)
{ return; }
virtual ~RsGxsIdSerialiser() { 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 sizeGxsIdGroupItem(RsGxsIdGroupItem *item);
bool serialiseGxsIdGroupItem (RsGxsIdGroupItem *item, void *data, uint32_t *size);
RsGxsIdGroupItem * deserialiseGxsIdGroupItem(void *data, uint32_t *size);
virtual uint32_t size (RsItem *item)
{
return dynamic_cast<RsGxsIdItem *>(item)->serial_size() ;
}
virtual bool serialise(RsItem *item, void *data, uint32_t *size)
{
return dynamic_cast<RsGxsIdItem *>(item)->serialise(data,*size) ;
}
virtual RsItem *deserialise (void *data, uint32_t *size) ;
private:
#if 0
uint32_t sizeGxsIdOpinionItem(RsGxsIdOpinionItem *item);
bool serialiseGxsIdOpinionItem (RsGxsIdOpinionItem *item, void *data, uint32_t *size);
RsGxsIdOpinionItem * deserialiseGxsIdOpinionItem(void *data, uint32_t *size);
uint32_t sizeGxsIdCommentItem(RsGxsIdCommentItem *item);
bool serialiseGxsIdCommentItem (RsGxsIdCommentItem *item, void *data, uint32_t *size);
RsGxsIdCommentItem * deserialiseGxsIdCommentItem(void *data, uint32_t *size);
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);
};
#endif /* RS_GXS_IDENTITY_ITEMS_H */

3
libretroshare/src/serialiser/rsserial.cc
View file

@ -52,7 +52,8 @@ RsItem::RsItem(uint32_t t)
{
_priority_level = QOS_PRIORITY_UNKNOWN ; // This value triggers PQIInterface to complain about undefined priorities
}
#ifdef DO_STATISTICS
class Counter
{

3
libretroshare/src/serialiser/rsserial.h
View file

@ -104,7 +104,8 @@ class RsItem: public RsMemoryManagement::SmallObject
void setPacketService(uint16_t service);
inline uint8_t priority_level() const { return _priority_level ;}
inline void setPriorityLevel(uint8_t l) { _priority_level = l ;}
inline void setPriorityLevel(uint8_t l) { _priority_level = l ;}
private:
uint32_t type;
RsPeerId peerId;

4
libretroshare/src/serialiser/rstlvstring.cc
View file

@ -218,14 +218,14 @@ std::ostream &RsTlvStringSet::printHex(std::ostream &out, uint16_t indent) const
/************************************* String Set Ref ************************************/
/* This is exactly the same as StringSet, but it uses an alternative list.
*/
RsTlvStringSetRef::RsTlvStringSetRef(uint16_t type, std::list<std::string> &refids)
RsTlvStringSetRef::RsTlvStringSetRef(uint16_t type, std::list<std::string> &refids)
:mType(type), ids(refids)
{
}
void RsTlvStringSetRef::TlvClear()
{
ids.clear();
ids.clear();
}

4
libretroshare/src/serialiser/rstlvstring.h
View file

@ -53,7 +53,7 @@ virtual std::ostream &printHex(std::ostream &out, uint16_t indent) const;
class RsTlvStringSetRef: public RsTlvItem
{
public:
RsTlvStringSetRef(uint16_t type, std::list<std::string> &refids);
RsTlvStringSetRef(uint16_t type, std::list<std::string> &refids);
virtual ~RsTlvStringSetRef() { return; }
virtual uint32_t TlvSize() const;
virtual void TlvClear();
@ -62,7 +62,7 @@ virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset);
virtual std::ostream &print(std::ostream &out, uint16_t indent) const;
uint16_t mType;
std::list<std::string> &ids; /* Mandatory */
std::list<std::string> &ids; /* Mandatory */
};