mirror of
https://github.com/RetroShare/RetroShare.git
synced 2025-06-28 16:17:28 -04:00
merge of branch v0.6-idclean 7180
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@7187 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
chrisparker126
parent
7815efb16f
commit
0f29d28b1b
397 changed files with 6503 additions and 5702 deletions
|
|
@ -215,105 +215,6 @@ bool setRawUFloat32(void *data,uint32_t size,uint32_t *offset,float f)
|
|||
return setRawUInt32(data, size, offset, n);
|
||||
}
|
||||
|
||||
bool getRawSha1(void *data,uint32_t size,uint32_t *offset,Sha1CheckSum& cs)
|
||||
{
|
||||
uint32_t len = Sha1CheckSum::SIZE_IN_BYTES ; // SHA1 length in bytes = 20
|
||||
|
||||
/* check there is space for string */
|
||||
if (size < *offset + len)
|
||||
{
|
||||
std::cerr << "getRawSha1() not enough size" << std::endl;
|
||||
return false;
|
||||
}
|
||||
bool ok = true ;
|
||||
|
||||
cs = Sha1CheckSum(&((uint8_t*)data)[*offset]) ;
|
||||
*offset += Sha1CheckSum::SIZE_IN_BYTES ;
|
||||
|
||||
return ok ;
|
||||
}
|
||||
|
||||
bool setRawSha1(void *data,uint32_t size,uint32_t *offset,const Sha1CheckSum& cs)
|
||||
{
|
||||
uint32_t len = Sha1CheckSum::SIZE_IN_BYTES ; // SHA1 length in bytes
|
||||
|
||||
if (size < *offset + len)
|
||||
{
|
||||
std::cerr << "setRawSha1() Not enough size" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ok = true ;
|
||||
/* pack it in */
|
||||
memcpy((void *) &(((uint8_t *) data)[*offset]), cs.toByteArray(), Sha1CheckSum::SIZE_IN_BYTES) ;
|
||||
offset += Sha1CheckSum::SIZE_IN_BYTES ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
bool getRawSSLId(void *data,uint32_t size,uint32_t *offset,SSLIdType& cs)
|
||||
{
|
||||
uint32_t len = 16 ; // SSL id type
|
||||
|
||||
/* check there is space for string */
|
||||
if (size < *offset + len)
|
||||
{
|
||||
std::cerr << "getRawSha1() not enough size" << std::endl;
|
||||
return false;
|
||||
}
|
||||
bool ok = true ;
|
||||
|
||||
cs = SSLIdType(&((uint8_t*)data)[*offset]) ;
|
||||
*offset += 16 ;
|
||||
|
||||
return ok ;
|
||||
}
|
||||
bool setRawSSLId(void *data,uint32_t size,uint32_t *offset,const SSLIdType& cs)
|
||||
{
|
||||
uint32_t len = 16 ; // SHA1 length in bytes
|
||||
|
||||
if (size < *offset + len)
|
||||
{
|
||||
std::cerr << "setRawSha1() Not enough size" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy((void *) &(((uint8_t *) data)[*offset]), cs.toByteArray(), 16);
|
||||
*offset += 16 ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
bool getRawPGPFingerprint(void *data,uint32_t size,uint32_t *offset,PGPFingerprintType& cs)
|
||||
{
|
||||
uint32_t len = 20 ; // SSL id type
|
||||
|
||||
/* check there is space for string */
|
||||
if (size < *offset + len)
|
||||
{
|
||||
std::cerr << "getRawPGPFingerprint() not enough size" << std::endl;
|
||||
return false;
|
||||
}
|
||||
bool ok = true ;
|
||||
|
||||
cs = PGPFingerprintType(&((uint8_t*)data)[*offset]) ;
|
||||
*offset += 20 ;
|
||||
|
||||
return ok ;
|
||||
}
|
||||
bool setRawPGPFingerprint(void *data,uint32_t size,uint32_t *offset,const PGPFingerprintType& cs)
|
||||
{
|
||||
uint32_t len = 20 ; // SHA1 length in bytes
|
||||
|
||||
if (size < *offset + len)
|
||||
{
|
||||
std::cerr << "setRawPGPFingerprint() Not enough size" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy((void *) &(((uint8_t *) data)[*offset]), cs.toByteArray(), 20);
|
||||
*offset += 20 ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
bool getRawString(void *data, uint32_t size, uint32_t *offset, std::string &outStr)
|
||||
{
|
||||
uint32_t len = 0;
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
#include <string>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <util/rsid.h>
|
||||
#include <retroshare/rsids.h>
|
||||
|
||||
/*******************************************************************
|
||||
* This is at the lowlevel packing routines. They are usually
|
||||
|
|
@ -66,15 +66,6 @@ bool setRawUFloat32(void *data, uint32_t size, uint32_t *offset, float in);
|
|||
bool getRawString(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 getRawSha1(void *data, uint32_t size, uint32_t *offset, Sha1CheckSum& outStr);
|
||||
bool setRawSha1(void *data, uint32_t size, uint32_t *offset, const Sha1CheckSum& inStr);
|
||||
|
||||
bool setRawSSLId(void *data, uint32_t size, uint32_t *offset, const SSLIdType& inStr);
|
||||
bool getRawSSLId(void *data, uint32_t size, uint32_t *offset, SSLIdType& outStr);
|
||||
|
||||
bool setRawPGPFingerprint(void *data, uint32_t size, uint32_t *offset, const PGPFingerprintType& inStr);
|
||||
bool getRawPGPFingerprint(void *data, uint32_t size, uint32_t *offset, PGPFingerprintType& 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);
|
||||
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ void RsFileTransfer::clear()
|
|||
|
||||
file.TlvClear();
|
||||
allPeerIds.TlvClear();
|
||||
cPeerId = "";
|
||||
cPeerId.clear() ;
|
||||
state = 0;
|
||||
in = false;
|
||||
transferred = 0;
|
||||
|
|
@ -197,7 +197,7 @@ uint32_t RsFileConfigSerialiser::sizeTransfer(RsFileTransfer *item)
|
|||
uint32_t s = 8; /* header */
|
||||
s += item->file.TlvSize();
|
||||
s += item->allPeerIds.TlvSize();
|
||||
s += GetTlvStringSize(item->cPeerId);
|
||||
s += RsPeerId::SIZE_IN_BYTES;
|
||||
s += 2; /* state */
|
||||
s += 2; /* in/out */
|
||||
s += 8; /* transferred */
|
||||
|
|
@ -239,7 +239,7 @@ bool RsFileConfigSerialiser::serialiseTransfer(RsFileTransfer *item, void *d
|
|||
ok &= item->file.SetTlv(data, tlvsize, &offset);
|
||||
ok &= item->allPeerIds.SetTlv(data, tlvsize, &offset);
|
||||
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->cPeerId);
|
||||
ok &= item->cPeerId.serialise(data, tlvsize, offset) ;
|
||||
|
||||
ok &= setRawUInt16(data, tlvsize, &offset, item->state);
|
||||
ok &= setRawUInt16(data, tlvsize, &offset, item->in);
|
||||
|
|
@ -305,8 +305,7 @@ RsFileTransfer *RsFileConfigSerialiser::deserialiseTransfer(void *data, uint32_t
|
|||
ok &= item->file.GetTlv(data, rssize, &offset);
|
||||
ok &= item->allPeerIds.GetTlv(data, rssize, &offset);
|
||||
|
||||
/* string */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->cPeerId);
|
||||
ok &= item->cPeerId.deserialise(data, rssize, offset) ;
|
||||
|
||||
/* data */
|
||||
ok &= getRawUInt16(data, rssize, &offset, &(item->state));
|
||||
|
|
@ -1185,7 +1184,7 @@ std::ostream &RsPeerGroupItem::print(std::ostream &out, uint16_t indent)
|
|||
printIndent(out, int_Indent);
|
||||
out << "groupFlag: " << flag << std::endl;
|
||||
|
||||
std::list<std::string>::iterator it;
|
||||
std::list<RsPgpId>::iterator it;
|
||||
for (it = peerIds.begin(); it != peerIds.end(); it++) {
|
||||
printIndent(out, int_Indent);
|
||||
out << "peerId: " << *it << std::endl;
|
||||
|
|
@ -1223,9 +1222,9 @@ uint32_t RsPeerConfigSerialiser::sizeGroup(RsPeerGroupItem *i)
|
|||
s += GetTlvStringSize(i->name);
|
||||
s += 4; /* flag */
|
||||
|
||||
std::list<std::string>::iterator it;
|
||||
std::list<RsPgpId>::iterator it;
|
||||
for (it = i->peerIds.begin(); it != i->peerIds.end(); it++) {
|
||||
s += GetTlvStringSize(*it);
|
||||
s += RsPgpId::SIZE_IN_BYTES ;
|
||||
}
|
||||
|
||||
return s;
|
||||
|
|
@ -1261,9 +1260,9 @@ bool RsPeerConfigSerialiser::serialiseGroup(RsPeerGroupItem *item, void *data, u
|
|||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->flag);
|
||||
|
||||
std::list<std::string>::iterator it;
|
||||
std::list<RsPgpId>::iterator it;
|
||||
for (it = item->peerIds.begin(); it != item->peerIds.end(); it++) {
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, *it);
|
||||
ok &= (*it).serialise(data, tlvsize, offset) ;
|
||||
}
|
||||
|
||||
if(offset != tlvsize)
|
||||
|
|
@ -1314,12 +1313,10 @@ RsPeerGroupItem *RsPeerConfigSerialiser::deserialiseGroup(void *data, uint32_t *
|
|||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->flag));
|
||||
|
||||
std::string peerId;
|
||||
while (offset != rssize) {
|
||||
peerId.erase();
|
||||
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, peerId);
|
||||
|
||||
RsPgpId peerId;
|
||||
while (offset != rssize)
|
||||
{
|
||||
ok &= peerId.deserialise(data, rssize, offset) ;
|
||||
item->peerIds.push_back(peerId);
|
||||
}
|
||||
|
||||
|
|
@ -1343,7 +1340,7 @@ std::ostream& RsPeerServicePermissionItem::print(std::ostream &out, uint16_t ind
|
|||
for(uint32_t i=0;i<pgp_ids.size();++i)
|
||||
{
|
||||
printIndent(out, int_Indent);
|
||||
out << "pgp id: " << pgp_ids[i] << ": " << service_flags[i].toUInt32() << std::endl;
|
||||
out << "pgp id: " << pgp_ids[i].toStdString() << ": " << service_flags[i].toUInt32() << std::endl;
|
||||
}
|
||||
printRsItemEnd(out, "RsPeerServicePermissionItem", indent);
|
||||
return out;
|
||||
|
|
@ -1356,7 +1353,7 @@ uint32_t RsPeerConfigSerialiser::sizePermissions(RsPeerServicePermissionItem *i)
|
|||
|
||||
for(uint32_t j=0;j<i->pgp_ids.size();++j)
|
||||
{
|
||||
s += GetTlvStringSize(i->pgp_ids[j]) ;
|
||||
s += RsPgpId::SIZE_IN_BYTES ;//GetTlvStringSize(i->pgp_ids[j]) ;
|
||||
s += 4; /* flag */
|
||||
}
|
||||
|
||||
|
|
@ -1392,7 +1389,7 @@ bool RsPeerConfigSerialiser::serialisePermissions(RsPeerServicePermissionItem *i
|
|||
|
||||
for(uint32_t i=0;i<item->pgp_ids.size();++i)
|
||||
{
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_KEY, item->pgp_ids[i]);
|
||||
ok &= item->pgp_ids[i].serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->service_flags[i].toUInt32());
|
||||
}
|
||||
|
||||
|
|
@ -1447,7 +1444,7 @@ RsPeerServicePermissionItem *RsPeerConfigSerialiser::deserialisePermissions(void
|
|||
for(uint32_t i=0;i<s;++i)
|
||||
{
|
||||
uint32_t flags ;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_KEY, item->pgp_ids[i]);
|
||||
ok &= item->pgp_ids[i].deserialise(data, rssize, offset) ;
|
||||
ok &= getRawUInt32(data, rssize, &offset, &flags);
|
||||
|
||||
item->service_flags[i] = ServicePermissionFlags(flags) ;
|
||||
|
|
@ -1481,7 +1478,7 @@ void RsCacheConfig::clear()
|
|||
cachesubid = 0;
|
||||
path = "";
|
||||
name = "";
|
||||
hash = "";
|
||||
hash.clear() ;
|
||||
size = 0;
|
||||
recvd = 0;
|
||||
|
||||
|
|
@ -1532,12 +1529,12 @@ uint32_t RsCacheConfigSerialiser::size(RsItem *i)
|
|||
uint32_t s = 8; // to store calculated size, initiailize with size of header
|
||||
|
||||
|
||||
s += GetTlvStringSize(item->pid);
|
||||
s += item->pid.serial_size();
|
||||
s += 2; /* cachetypeid */
|
||||
s += 2; /* cachesubid */
|
||||
s += GetTlvStringSize(item->path);
|
||||
s += GetTlvStringSize(item->name);
|
||||
s += GetTlvStringSize(item->hash);
|
||||
s += item->hash.serial_size();
|
||||
s += 8; /* size */
|
||||
s += 4; /* recvd */
|
||||
|
||||
|
|
@ -1569,12 +1566,12 @@ bool RsCacheConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *size)
|
|||
|
||||
/* add the mandatory parts first */
|
||||
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->pid);
|
||||
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 &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_SHA1, item->hash);
|
||||
ok &= item->hash.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt64(data, tlvsize, &offset, item->size);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, item->recvd);
|
||||
|
||||
|
|
@ -1622,12 +1619,12 @@ RsItem *RsCacheConfigSerialiser::deserialise(void *data, uint32_t *size)
|
|||
|
||||
/* get mandatory parts first */
|
||||
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->pid);
|
||||
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 &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_HASH_SHA1, item->hash);
|
||||
ok &= item->hash.deserialise(data, rssize, offset) ;
|
||||
ok &= getRawUInt64(data, rssize, &offset, &(item->size));
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->recvd));
|
||||
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ class RsPeerServicePermissionItem : public RsItem
|
|||
std::ostream &print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
/* Mandatory */
|
||||
std::vector<std::string> pgp_ids ;
|
||||
std::vector<RsPgpId> pgp_ids ;
|
||||
std::vector<ServicePermissionFlags> service_flags ;
|
||||
};
|
||||
class RsPeerGroupItem : public RsItem
|
||||
|
|
@ -131,7 +131,7 @@ public:
|
|||
std::string name;
|
||||
uint32_t flag;
|
||||
|
||||
std::list<std::string> peerIds;
|
||||
std::list<RsPgpId> peerIds;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -201,13 +201,13 @@ virtual ~RsCacheConfig();
|
|||
virtual void clear();
|
||||
std::ostream &print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string pid; /* Mandatory */
|
||||
RsPeerId pid; /* Mandatory */
|
||||
uint16_t cachetypeid; /* Mandatory */
|
||||
uint16_t cachesubid; /* Mandatory */
|
||||
|
||||
std::string path; /* Mandatory */
|
||||
std::string name; /* Mandatory */
|
||||
std::string hash; /* Mandatory */
|
||||
RsFileHash hash; /* Mandatory */
|
||||
uint64_t size; /* Mandatory */
|
||||
|
||||
uint32_t recvd; /* Mandatory */
|
||||
|
|
@ -254,7 +254,7 @@ class RsFileTransfer: public RsItem
|
|||
RsTlvFileItem file;
|
||||
RsTlvPeerIdSet allPeerIds;
|
||||
|
||||
std::string cPeerId;
|
||||
RsPeerId cPeerId;
|
||||
|
||||
uint16_t state;
|
||||
uint16_t in;
|
||||
|
|
|
|||
|
|
@ -442,7 +442,7 @@ std::ostream &RsDiscPgpCertItem::print(std::ostream &out, uint16_t indent)
|
|||
uint32_t RsDiscSerialiser::sizePgpCert(RsDiscPgpCertItem *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += GetTlvStringSize(item->pgpId);
|
||||
s += item->pgpId.serial_size();
|
||||
s += GetTlvStringSize(item->pgpCert);
|
||||
return s;
|
||||
}
|
||||
|
|
@ -471,7 +471,7 @@ bool RsDiscSerialiser::serialisePgpCert(RsDiscPgpCertItem *item, void *data,
|
|||
offset += 8;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PGPID, item->pgpId);
|
||||
ok &= item->pgpId.serialise(data, tlvsize, offset) ;
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PGPCERT, item->pgpCert);
|
||||
|
||||
if (offset != tlvsize) {
|
||||
|
|
@ -523,7 +523,7 @@ RsDiscPgpCertItem *RsDiscSerialiser::deserialisePgpCert(void *data, uint32_t *pk
|
|||
offset += 8;
|
||||
|
||||
/* get mandatory parts first */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PGPID, item->pgpId);
|
||||
ok &= item->pgpId.deserialise(data, rssize, offset) ;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PGPCERT, item->pgpCert);
|
||||
|
||||
if (offset != rssize) {
|
||||
|
|
@ -659,8 +659,8 @@ std::ostream &RsDiscContactItem::print(std::ostream &out, uint16_t indent)
|
|||
uint32_t RsDiscSerialiser::sizeContact(RsDiscContactItem *item)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += GetTlvStringSize(item->pgpId);
|
||||
s += GetTlvStringSize(item->sslId);
|
||||
s += item->pgpId.serial_size();
|
||||
s += item->sslId.serial_size();
|
||||
|
||||
s += GetTlvStringSize(item->location);
|
||||
s += GetTlvStringSize(item->version);
|
||||
|
|
@ -733,8 +733,8 @@ bool RsDiscSerialiser::serialiseContact(RsDiscContactItem *item, void *data,
|
|||
offset += 8;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PGPID, item->pgpId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->sslId);
|
||||
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);
|
||||
|
|
@ -818,8 +818,8 @@ RsDiscContactItem *RsDiscSerialiser::deserialiseContact(void *data, uint32_t *pk
|
|||
offset += 8;
|
||||
|
||||
/* get mandatory parts first */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PGPID, item->pgpId);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->sslId);
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ virtual ~RsDiscPgpCertItem();
|
|||
virtual void clear();
|
||||
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string pgpId;
|
||||
RsPgpId pgpId;
|
||||
std::string pgpCert;
|
||||
};
|
||||
|
||||
|
|
@ -106,8 +106,8 @@ virtual ~RsDiscContactItem();
|
|||
virtual void clear();
|
||||
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string pgpId;
|
||||
std::string sslId;
|
||||
RsPgpId pgpId;
|
||||
RsPeerId sslId;
|
||||
|
||||
// COMMON
|
||||
std::string location;
|
||||
|
|
|
|||
|
|
@ -176,7 +176,7 @@ uint32_t RsFileTransferChunkMapRequestItem::serial_size()
|
|||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += 1 ; // is_client
|
||||
s += GetTlvStringSize(hash) ; // hash
|
||||
s += hash.serial_size() ; // hash
|
||||
|
||||
return s;
|
||||
}
|
||||
|
|
@ -184,7 +184,7 @@ uint32_t RsFileTransferChunkMapItem::serial_size()
|
|||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += 1 ; // is_client
|
||||
s += GetTlvStringSize(hash) ; // hash
|
||||
s += hash.serial_size() ; // hash
|
||||
s += 4 ; // compressed map size
|
||||
s += 4 * compressed_map._map.size() ; // compressed chunk map
|
||||
|
||||
|
|
@ -193,17 +193,17 @@ uint32_t RsFileTransferChunkMapItem::serial_size()
|
|||
uint32_t RsFileTransferSingleChunkCrcItem::serial_size()
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += GetTlvStringSize(hash) ; // hash
|
||||
s += hash.serial_size() ; // hash
|
||||
s += 4 ; // chunk number
|
||||
s += 20 ; // sha1
|
||||
s += check_sum.serial_size() ; // sha1
|
||||
|
||||
return s;
|
||||
}
|
||||
uint32_t RsFileTransferSingleChunkCrcRequestItem::serial_size()
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += GetTlvStringSize(hash) ; // hash
|
||||
s += 4 ; // chunk number
|
||||
s += hash.serial_size() ; // hash
|
||||
s += 4 ; // chunk number
|
||||
|
||||
return s;
|
||||
}
|
||||
|
|
@ -267,7 +267,7 @@ bool RsFileTransferChunkMapRequestItem::serialise(void *data, uint32_t& pktsize)
|
|||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt8(data, tlvsize, &offset, is_client);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, hash);
|
||||
ok &= hash.serialise(data, tlvsize, offset) ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
|
|
@ -286,7 +286,7 @@ bool RsFileTransferSingleChunkCrcRequestItem::serialise(void *data, uint32_t& pk
|
|||
return false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, hash);
|
||||
ok &= hash.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, chunk_number) ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
|
|
@ -306,10 +306,10 @@ bool RsFileTransferSingleChunkCrcItem::serialise(void *data, uint32_t& pktsize)
|
|||
return false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, hash);
|
||||
ok &= hash.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, chunk_number) ;
|
||||
|
||||
setRawSha1(data,tlvsize,&offset,check_sum) ;
|
||||
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]) ;
|
||||
|
|
@ -335,7 +335,7 @@ bool RsFileTransferChunkMapItem::serialise(void *data, uint32_t& pktsize)
|
|||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt8(data, tlvsize, &offset, is_client);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, hash);
|
||||
ok &= hash.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, compressed_map._map.size());
|
||||
|
||||
for(uint32_t i=0;i<compressed_map._map.size();++i)
|
||||
|
|
@ -517,7 +517,7 @@ RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferChunkMap
|
|||
offset += 8;
|
||||
uint8_t tmp ;
|
||||
ok &= getRawUInt8(data, rssize, &offset, &tmp); item->is_client = tmp;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->hash); // file hash
|
||||
ok &= item->hash.deserialise(data, rssize, offset) ; // File hash
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
|
|
@ -675,8 +675,8 @@ RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferChunkMap
|
|||
offset += 8;
|
||||
uint8_t tmp ;
|
||||
ok &= getRawUInt8(data, rssize, &offset, &tmp); item->is_client = tmp;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->hash); // file hash
|
||||
uint32_t size =0;
|
||||
ok &= item->hash.deserialise(data, rssize, offset) ; // File hash
|
||||
uint32_t size =0;
|
||||
ok &= getRawUInt32(data, rssize, &offset, &size);
|
||||
|
||||
if(ok)
|
||||
|
|
@ -731,7 +731,7 @@ RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferSingleCh
|
|||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->hash); // file hash
|
||||
ok &= item->hash.deserialise(data, rssize, offset) ;
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->chunk_number));
|
||||
|
||||
if (offset != rssize)
|
||||
|
|
@ -777,11 +777,11 @@ RsFileTransferItem *RsFileTransferSerialiser::deserialise_RsFileTransferSingleCh
|
|||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->hash); // file hash
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->chunk_number));
|
||||
getRawSha1(data,rssize,&offset,item->check_sum) ;
|
||||
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)
|
||||
if (offset != rssize)
|
||||
{
|
||||
/* error */
|
||||
delete item;
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ class RsFileTransferChunkMapRequestItem: public RsFileTransferItem
|
|||
// Private data part.
|
||||
//
|
||||
bool is_client ; // is the request for a client, or a server ?
|
||||
std::string hash ; // hash of the file for which we request the chunk map
|
||||
RsFileHash hash ; // hash of the file for which we request the chunk map
|
||||
};
|
||||
|
||||
class RsFileTransferChunkMapItem: public RsFileTransferItem
|
||||
|
|
@ -149,7 +149,7 @@ class RsFileTransferChunkMapItem: public RsFileTransferItem
|
|||
// Private data part.
|
||||
//
|
||||
bool is_client ; // is the request for a client, or a server ?
|
||||
std::string hash ; // hash of the file for which we request the chunk map
|
||||
RsFileHash hash ; // hash of the file for which we request the chunk map
|
||||
CompressedChunkMap compressed_map ; // Chunk map of the file.
|
||||
};
|
||||
|
||||
|
|
@ -169,7 +169,7 @@ class RsFileTransferSingleChunkCrcRequestItem: public RsFileTransferItem
|
|||
|
||||
// Private data part.
|
||||
//
|
||||
std::string hash ; // hash of the file for which we request the crc
|
||||
RsFileHash hash ; // hash of the file for which we request the crc
|
||||
uint32_t chunk_number ; // chunk number
|
||||
};
|
||||
|
||||
|
|
@ -189,7 +189,7 @@ class RsFileTransferSingleChunkCrcItem: public RsFileTransferItem
|
|||
|
||||
// Private data part.
|
||||
//
|
||||
std::string hash ; // hash of the file for which we request the chunk map
|
||||
RsFileHash hash ; // hash of the file for which we request the chunk map
|
||||
uint32_t chunk_number ;
|
||||
Sha1CheckSum check_sum ; // CRC32 map of the file.
|
||||
};
|
||||
|
|
|
|||
|
|
@ -393,7 +393,7 @@ bool RsGxsChannelPostItem::toChannelPost(RsGxsChannelPost &post, bool moveImage)
|
|||
RsGxsFile fi;
|
||||
fi.mName = RsDirUtil::getTopDir(fit->name);
|
||||
fi.mSize = fit->filesize;
|
||||
fi.mHash = fit->hash;
|
||||
fi.mHash = fit->hash.toStdString();
|
||||
|
||||
post.mFiles.push_back(fi);
|
||||
post.mCount++;
|
||||
|
|
|
|||
|
|
@ -121,13 +121,26 @@ bool RsGxsCircleGroupItem::convertFrom(const RsGxsCircleGroup &group)
|
|||
// Enforce the local rules.
|
||||
if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL)
|
||||
{
|
||||
pgpIdSet.ids = group.mLocalFriends;
|
||||
std::list<RsPgpId>::const_iterator it = group.mLocalFriends.begin();
|
||||
|
||||
for(; it != group.mLocalFriends.end(); it++)
|
||||
pgpIdSet.ids.push_back(it->toStdString());
|
||||
}
|
||||
else
|
||||
{
|
||||
gxsIdSet.ids = group.mInvitedMembers;
|
||||
std::list<RsGxsId>::const_iterator it = group.mInvitedMembers.begin();
|
||||
for(; it != group.mInvitedMembers.end(); it++)
|
||||
{
|
||||
gxsIdSet.ids.push_back(it->toStdString());
|
||||
}
|
||||
}
|
||||
subCircleSet.ids = group.mSubCircles;
|
||||
const std::list<RsGxsCircleId>& scl = group.mSubCircles;
|
||||
|
||||
std::list<RsGxsCircleId>::const_iterator cit = scl.begin();
|
||||
subCircleSet.ids.clear();
|
||||
for(; cit != scl.end(); cit++)
|
||||
subCircleSet.ids.push_back(cit->toStdString());
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -138,15 +151,27 @@ bool RsGxsCircleGroupItem::convertTo(RsGxsCircleGroup &group) const
|
|||
// Enforce the local rules.
|
||||
if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL)
|
||||
{
|
||||
group.mLocalFriends = pgpIdSet.ids;
|
||||
std::list<std::string>::const_iterator it = pgpIdSet.ids.begin();
|
||||
for(; it != pgpIdSet.ids.end(); it++)
|
||||
group.mLocalFriends.push_back(RsPgpId(*it));
|
||||
group.mInvitedMembers.clear();
|
||||
}
|
||||
else
|
||||
{
|
||||
group.mLocalFriends.clear();
|
||||
group.mInvitedMembers = gxsIdSet.ids;
|
||||
std::list<std::string>::const_iterator cit = gxsIdSet.ids.begin();
|
||||
for(; cit != gxsIdSet.ids.end(); cit++)
|
||||
group.mInvitedMembers.push_back((RsGxsId(*cit)));
|
||||
|
||||
}
|
||||
group.mSubCircles = subCircleSet.ids;
|
||||
|
||||
const std::list<std::string> scs = subCircleSet.ids;
|
||||
std::list<std::string>::const_iterator cit = scs.begin();
|
||||
|
||||
group.mSubCircles.clear();
|
||||
|
||||
for(; cit != scs.end(); cit++)
|
||||
group.mSubCircles.push_back(RsGxsCircleId(*cit));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ uint32_t RsGxsRecognSerialiser::sizeReq(RsGxsRecognReqItem *item)
|
|||
s += 4; // period;
|
||||
s += 2; // tag_class;
|
||||
s += 2; // tag_type;
|
||||
s += GetTlvStringSize(item->identity);
|
||||
s += item->identity.serial_size();
|
||||
s += GetTlvStringSize(item->nickname);
|
||||
s += GetTlvStringSize(item->comment);
|
||||
s += item->sign.TlvSize();
|
||||
|
|
@ -133,9 +133,11 @@ bool RsGxsRecognSerialiser::serialiseReq(RsGxsRecognReqItem *item, void *dat
|
|||
ok &= setRawUInt16(data, tlvsize, &offset, item->tag_class);
|
||||
ok &= setRawUInt16(data, tlvsize, &offset, item->tag_type);
|
||||
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GXS_ID, item->identity);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->nickname);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_COMMENT, item->comment);
|
||||
|
||||
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);
|
||||
|
||||
|
||||
|
|
@ -186,9 +188,10 @@ RsGxsRecognReqItem *RsGxsRecognSerialiser::deserialiseReq(void *data, uint32_t *
|
|||
ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_class));
|
||||
ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_type));
|
||||
|
||||
ok &= GetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity);
|
||||
ok &= GetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GXS_ID, item->nickname);
|
||||
ok &= GetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_COMMENT, item->comment);
|
||||
|
||||
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);
|
||||
|
||||
|
||||
|
|
@ -269,7 +272,7 @@ uint32_t RsGxsRecognSerialiser::sizeTag(RsGxsRecognTagItem *item)
|
|||
s += 2; // tag_class;
|
||||
s += 2; // tag_type;
|
||||
|
||||
s += GetTlvStringSize(item->identity);
|
||||
s += item->identity.serial_size();
|
||||
s += GetTlvStringSize(item->nickname);
|
||||
|
||||
s += item->sign.TlvSize();
|
||||
|
|
@ -307,8 +310,10 @@ bool RsGxsRecognSerialiser::serialiseTag(RsGxsRecognTagItem *item, void *dat
|
|||
ok &= setRawUInt16(data, tlvsize, &offset, item->tag_class);
|
||||
ok &= setRawUInt16(data, tlvsize, &offset, item->tag_type);
|
||||
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GXS_ID, item->identity);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->nickname);
|
||||
|
||||
ok &= item->identity.serialise(data, tlvsize, offset);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, 1, item->nickname);
|
||||
|
||||
ok &= item->sign.SetTlv(data, tlvsize, &offset);
|
||||
|
||||
|
||||
|
|
@ -360,8 +365,9 @@ RsGxsRecognTagItem *RsGxsRecognSerialiser::deserialiseTag(void *data, uint32_t *
|
|||
ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_class));
|
||||
ok &= getRawUInt16(data, tlvsize, &offset, &(item->tag_type));
|
||||
|
||||
ok &= GetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GXS_ID, item->identity);
|
||||
ok &= GetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->nickname);
|
||||
|
||||
ok &= item->identity.deserialise(data, tlvsize, offset);
|
||||
ok &= GetTlvString(data, tlvsize, &offset, 1, item->nickname);
|
||||
ok &= item->sign.GetTlv(data, tlvsize, &offset);
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -34,6 +34,8 @@
|
|||
#include "serialiser/rstlvtypes.h"
|
||||
#include "serialiser/rstlvkeys.h"
|
||||
|
||||
#include "retroshare/rsgxsifacetypes.h"
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
#define RS_PKT_SUBTYPE_RECOGN_REQ 0x01
|
||||
|
|
@ -61,7 +63,7 @@ std::ostream &print(std::ostream &out, uint16_t indent = 0);
|
|||
uint16_t tag_class;
|
||||
uint16_t tag_type;
|
||||
|
||||
std::string identity;
|
||||
RsGxsId identity;
|
||||
std::string nickname;
|
||||
std::string comment;
|
||||
|
||||
|
|
@ -88,7 +90,7 @@ std::ostream &print(std::ostream &out, uint16_t indent = 0);
|
|||
uint16_t tag_class;
|
||||
uint16_t tag_type;
|
||||
|
||||
std::string identity;
|
||||
RsGxsId identity;
|
||||
std::string nickname;
|
||||
|
||||
RsTlvKeySignature sign;
|
||||
|
|
|
|||
|
|
@ -177,7 +177,7 @@ RsItem* RsGxsUpdateSerialiser::deserialise(void* data, uint32_t* size)
|
|||
uint32_t RsGxsUpdateSerialiser::sizeGxsGrpUpdate(RsGxsGrpUpdateItem* item)
|
||||
{
|
||||
uint32_t s = 8; // header size
|
||||
s += GetTlvStringSize(item->peerId);
|
||||
s += item->peerId.serial_size();
|
||||
s += 4;
|
||||
return s;
|
||||
}
|
||||
|
|
@ -218,7 +218,7 @@ bool RsGxsUpdateSerialiser::serialiseGxsGrpUpdate(RsGxsGrpUpdateItem* item,
|
|||
/* RsGxsGrpUpdateItem */
|
||||
|
||||
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_PEERID, item->peerId);
|
||||
ok &= item->peerId.serialise(data, *size, offset) ;
|
||||
ok &= setRawUInt32(data, *size, &offset, item->grpUpdateTS);
|
||||
|
||||
if(offset != tlvsize){
|
||||
|
|
@ -326,7 +326,7 @@ RsGxsGrpUpdateItem* RsGxsUpdateSerialiser::deserialGxsGrpUpddate(void* data,
|
|||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_PEERID, item->peerId);
|
||||
ok &= item->peerId.deserialise(data, *size, offset) ;
|
||||
ok &= getRawUInt32(data, *size, &offset, &(item->grpUpdateTS));
|
||||
|
||||
if (offset != rssize)
|
||||
|
|
@ -419,15 +419,15 @@ RsGxsServerGrpUpdateItem* RsGxsUpdateSerialiser::deserialGxsServerGrpUpddate(voi
|
|||
uint32_t RsGxsUpdateSerialiser::sizeGxsMsgUpdate(RsGxsMsgUpdateItem* item)
|
||||
{
|
||||
uint32_t s = 8; // header size
|
||||
s += GetTlvStringSize(item->peerId);
|
||||
s += item->peerId.serial_size() ;//GetTlvStringSize(item->peerId);
|
||||
|
||||
const std::map<std::string, uint32_t>& msgUpdateTS = item->msgUpdateTS;
|
||||
std::map<std::string, uint32_t>::const_iterator cit = msgUpdateTS.begin();
|
||||
const std::map<RsGxsGroupId, uint32_t>& msgUpdateTS = item->msgUpdateTS;
|
||||
std::map<RsGxsGroupId, uint32_t>::const_iterator cit = msgUpdateTS.begin();
|
||||
|
||||
for(; cit != msgUpdateTS.end(); cit++)
|
||||
{
|
||||
s += GetTlvStringSize(cit->first);
|
||||
s += 4;
|
||||
s += cit->first.serial_size();
|
||||
s += 4;
|
||||
}
|
||||
|
||||
s += 4; // number of map items
|
||||
|
|
@ -438,7 +438,7 @@ uint32_t RsGxsUpdateSerialiser::sizeGxsMsgUpdate(RsGxsMsgUpdateItem* item)
|
|||
uint32_t RsGxsUpdateSerialiser::sizeGxsServerMsgUpdate(RsGxsServerMsgUpdateItem* item)
|
||||
{
|
||||
uint32_t s = 8; // header size
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += item->grpId.serial_size();
|
||||
s += 4; // grp TS
|
||||
|
||||
return s;
|
||||
|
|
@ -473,17 +473,17 @@ bool RsGxsUpdateSerialiser::serialiseGxsMsgUpdate(RsGxsMsgUpdateItem* item,
|
|||
/* RsGxsMsgUpdateItem */
|
||||
|
||||
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_PEERID, item->peerId);
|
||||
ok &= item->peerId.serialise(data, *size, offset) ;
|
||||
|
||||
const std::map<std::string, uint32_t>& msgUpdateTS = item->msgUpdateTS;
|
||||
std::map<std::string, uint32_t>::const_iterator cit = msgUpdateTS.begin();
|
||||
const std::map<RsGxsGroupId, uint32_t>& msgUpdateTS = item->msgUpdateTS;
|
||||
std::map<RsGxsGroupId, uint32_t>::const_iterator cit = msgUpdateTS.begin();
|
||||
|
||||
uint32_t numItems = msgUpdateTS.size();
|
||||
ok &= setRawUInt32(data, *size, &offset, numItems);
|
||||
|
||||
for(; cit != msgUpdateTS.end(); cit++)
|
||||
{
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, cit->first);
|
||||
ok &= cit->first.serialise(data, *size, offset);
|
||||
ok &= setRawUInt32(data, *size, &offset, cit->second);
|
||||
}
|
||||
|
||||
|
|
@ -533,7 +533,7 @@ bool RsGxsUpdateSerialiser::serialiseGxsServerMsgUpdate(RsGxsServerMsgUpdateItem
|
|||
/* RsNxsSyncm */
|
||||
|
||||
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->grpId.serialise(data, *size, offset) ;
|
||||
ok &= setRawUInt32(data, *size, &offset, item->msgUpdateTS);
|
||||
|
||||
if(offset != tlvsize){
|
||||
|
|
@ -594,15 +594,15 @@ RsGxsMsgUpdateItem* RsGxsUpdateSerialiser::deserialGxsMsgUpdate(void* data,
|
|||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_PEERID, item->peerId);
|
||||
ok &= item->peerId.deserialise(data, *size, offset) ;
|
||||
uint32_t numUpdateItems;
|
||||
ok &= getRawUInt32(data, *size, &offset, &(numUpdateItems));
|
||||
std::map<std::string, uint32_t>& msgUpdateItem = item->msgUpdateTS;
|
||||
std::string grpId;
|
||||
std::map<RsGxsGroupId, uint32_t>& msgUpdateItem = item->msgUpdateTS;
|
||||
RsGxsGroupId pId;
|
||||
uint32_t updateTS;
|
||||
for(uint32_t i = 0; i < numUpdateItems; i++)
|
||||
{
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, grpId);
|
||||
ok &= pId.deserialise(data, *size, offset);
|
||||
|
||||
if(!ok)
|
||||
break;
|
||||
|
|
@ -612,7 +612,7 @@ RsGxsMsgUpdateItem* RsGxsUpdateSerialiser::deserialGxsMsgUpdate(void* data,
|
|||
if(!ok)
|
||||
break;
|
||||
|
||||
msgUpdateItem.insert(std::make_pair(grpId, updateTS));
|
||||
msgUpdateItem.insert(std::make_pair(pId, updateTS));
|
||||
}
|
||||
|
||||
if (offset != rssize)
|
||||
|
|
@ -678,7 +678,7 @@ RsGxsServerMsgUpdateItem* RsGxsUpdateSerialiser::deserialGxsServerMsgUpdate(void
|
|||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->grpId.deserialise(data, *size, offset) ;
|
||||
ok &= getRawUInt32(data, *size, &offset, &(item->msgUpdateTS));
|
||||
|
||||
if (offset != rssize)
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ public:
|
|||
virtual void clear();
|
||||
virtual std::ostream &print(std::ostream &out, uint16_t indent);
|
||||
|
||||
std::string peerId;
|
||||
RsPeerId peerId;
|
||||
uint32_t grpUpdateTS;
|
||||
};
|
||||
|
||||
|
|
@ -79,8 +79,8 @@ public:
|
|||
virtual void clear();
|
||||
virtual std::ostream &print(std::ostream &out, uint16_t indent);
|
||||
|
||||
std::string peerId;
|
||||
std::map<std::string, uint32_t> msgUpdateTS;
|
||||
RsPeerId peerId;
|
||||
std::map<RsGxsGroupId, uint32_t> msgUpdateTS;
|
||||
};
|
||||
|
||||
class RsGxsServerMsgUpdateItem : public RsItem
|
||||
|
|
@ -94,7 +94,7 @@ public:
|
|||
virtual void clear();
|
||||
virtual std::ostream &print(std::ostream &out, uint16_t indent);
|
||||
|
||||
std::string grpId;
|
||||
RsGxsGroupId grpId;
|
||||
uint32_t msgUpdateTS; // the last time this group received a new msg
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -104,9 +104,9 @@ uint32_t RsHistorySerialiser::sizeHistoryMsgItem(RsHistoryMsgItem* item)
|
|||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += 2; /* version */
|
||||
s += GetTlvStringSize(item->chatPeerId);
|
||||
s += item->chatPeerId.serial_size();
|
||||
s += 1; /* incoming */
|
||||
s += GetTlvStringSize(item->peerId);
|
||||
s += item->peerId.serial_size();
|
||||
s += GetTlvStringSize(item->peerName);
|
||||
s += 4; /* sendTime */
|
||||
s += 4; /* recvTime */
|
||||
|
|
@ -140,10 +140,10 @@ bool RsHistorySerialiser::serialiseHistoryMsgItem(RsHistoryMsgItem* item, void*
|
|||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt16(data, tlvsize, &offset, 0); // version
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->chatPeerId);
|
||||
ok &= item->chatPeerId.serialise(data, tlvsize, offset) ;
|
||||
uint8_t dummy = item->incoming ? 1 : 0;
|
||||
ok &= setRawUInt8(data, tlvsize, &offset, dummy);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->peerId);
|
||||
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);
|
||||
|
|
@ -194,11 +194,11 @@ RsHistoryMsgItem *RsHistorySerialiser::deserialiseHistoryMsgItem(void *data, uin
|
|||
/* get mandatory parts first */
|
||||
uint16_t version = 0;
|
||||
ok &= getRawUInt16(data, rssize, &offset, &version);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->chatPeerId);
|
||||
ok &= item->chatPeerId.deserialise(data, rssize, offset) ;
|
||||
uint8_t dummy;
|
||||
ok &= getRawUInt8(data, rssize, &offset, &dummy);
|
||||
item->incoming = (dummy == 1);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->peerId);
|
||||
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));
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "retroshare/rstypes.h"
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
|
|
@ -40,9 +41,9 @@ public:
|
|||
virtual void clear();
|
||||
std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string chatPeerId; // empty for global chat
|
||||
RsPeerId chatPeerId; // empty for global chat
|
||||
bool incoming;
|
||||
std::string peerId;
|
||||
RsPeerId peerId;
|
||||
std::string peerName;
|
||||
uint32_t sendTime;
|
||||
uint32_t recvTime;
|
||||
|
|
|
|||
|
|
@ -418,7 +418,7 @@ uint32_t RsPrivateChatMsgConfigItem::serial_size()
|
|||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += 4; /* version */
|
||||
s += GetTlvStringSize(configPeerId);
|
||||
s += configPeerId.serial_size();
|
||||
s += 4; /* chatFlags */
|
||||
s += 4; /* configFlags */
|
||||
s += 4; /* sendTime */
|
||||
|
|
@ -430,9 +430,9 @@ uint32_t RsPrivateChatMsgConfigItem::serial_size()
|
|||
uint32_t RsPrivateChatDistantInviteConfigItem::serial_size()
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
s += GetTlvStringSize(hash);
|
||||
s += hash.serial_size();
|
||||
s += GetTlvStringSize(encrypted_radix64_string);
|
||||
s += GetTlvStringSize(destination_pgp_id);
|
||||
s += destination_pgp_id.serial_size();
|
||||
s += 16; /* aes_key */
|
||||
s += 4; /* time_of_validity */
|
||||
s += 4; /* last_hit_time */
|
||||
|
|
@ -807,7 +807,7 @@ bool RsPrivateChatMsgConfigItem::serialise(void *data, uint32_t& pktsize)
|
|||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, 0);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, configPeerId);
|
||||
ok &= configPeerId.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, chatFlags);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, configFlags);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, sendTime);
|
||||
|
|
@ -845,9 +845,9 @@ bool RsPrivateChatDistantInviteConfigItem::serialise(void *data, uint32_t& pktsi
|
|||
offset += 8;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_KEY, hash);
|
||||
ok &= hash.serialise(data, tlvsize, offset) ;
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LINK, encrypted_radix64_string);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GPGID, destination_pgp_id);
|
||||
ok &= destination_pgp_id.serialise(data, tlvsize, offset);
|
||||
|
||||
memcpy(&((unsigned char *)data)[offset],aes_key,16) ;
|
||||
offset += 16 ;
|
||||
|
|
@ -1229,7 +1229,7 @@ RsPrivateChatMsgConfigItem::RsPrivateChatMsgConfigItem(void *data,uint32_t /*siz
|
|||
/* get mandatory parts first */
|
||||
uint32_t version = 0;
|
||||
ok &= getRawUInt32(data, rssize, &offset, &version);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, configPeerId);
|
||||
ok &= configPeerId.deserialise(data, rssize, offset);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &chatFlags);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &configFlags);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &sendTime);
|
||||
|
|
@ -1252,9 +1252,9 @@ RsPrivateChatDistantInviteConfigItem::RsPrivateChatDistantInviteConfigItem(void
|
|||
bool ok = true ;
|
||||
|
||||
/* get mandatory parts first */
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_KEY, hash);
|
||||
ok &= hash.deserialise(data, rssize, offset) ;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LINK, encrypted_radix64_string);
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GPGID, destination_pgp_id);
|
||||
ok &= destination_pgp_id.serialise(data, rssize, offset);
|
||||
|
||||
memcpy(aes_key,&((unsigned char*)data)[offset],16) ;
|
||||
offset += 16 ;
|
||||
|
|
@ -1296,7 +1296,7 @@ RsChatLobbyConfigItem::RsChatLobbyConfigItem(void *data,uint32_t /*size*/)
|
|||
}
|
||||
|
||||
/* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */
|
||||
void RsPrivateChatMsgConfigItem::set(RsChatMsgItem *ci, const std::string &/*peerId*/, uint32_t confFlags)
|
||||
void RsPrivateChatMsgConfigItem::set(RsChatMsgItem *ci, const RsPeerId& /*peerId*/, uint32_t confFlags)
|
||||
{
|
||||
PeerId(ci->PeerId());
|
||||
configPeerId = ci->PeerId();
|
||||
|
|
@ -1982,7 +1982,7 @@ uint32_t RsMsgSrcId::serial_size(bool)
|
|||
uint32_t s = 8; /* header */
|
||||
|
||||
s += 4;
|
||||
s += GetTlvStringSize(srcId);
|
||||
s += srcId.serial_size() ;
|
||||
|
||||
return s;
|
||||
}
|
||||
|
|
@ -2011,7 +2011,7 @@ bool RsMsgSrcId::serialise(void *data, uint32_t& pktsize,bool config)
|
|||
offset += 8;
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, msgId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, srcId);
|
||||
ok &= srcId.serialise(data, tlvsize, offset) ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
|
|
@ -2056,7 +2056,7 @@ RsMsgSrcId* RsMsgSerialiser::deserialiseMsgSrcIdItem(void* data, uint32_t* pktsi
|
|||
|
||||
/* get mandatory parts first */
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->msgId));
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->srcId);
|
||||
ok &= item->srcId.deserialise(data, rssize, offset);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
|
||||
#include <map>
|
||||
|
||||
#include "retroshare/rstypes.h"
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "serialiser/rstlvtypes.h"
|
||||
|
|
@ -308,11 +309,11 @@ class RsPrivateChatMsgConfigItem: public RsChatItem
|
|||
virtual uint32_t serial_size() ; // deserialise is handled using a constructor
|
||||
|
||||
/* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */
|
||||
void set(RsChatMsgItem *ci, const std::string &peerId, uint32_t confFlags);
|
||||
void set(RsChatMsgItem *ci, const RsPeerId &peerId, uint32_t confFlags);
|
||||
/* get data from RsPrivateChatMsgConfigItem to RsChatMsgItem */
|
||||
void get(RsChatMsgItem *ci);
|
||||
|
||||
std::string configPeerId;
|
||||
RsPeerId configPeerId;
|
||||
uint32_t chatFlags;
|
||||
uint32_t configFlags;
|
||||
uint32_t sendTime;
|
||||
|
|
@ -333,9 +334,9 @@ class RsPrivateChatDistantInviteConfigItem: public RsChatItem
|
|||
virtual uint32_t serial_size() ; // deserialise is handled using a constructor
|
||||
|
||||
unsigned char aes_key[16] ;
|
||||
std::string hash ;
|
||||
RsFileHash hash ;
|
||||
std::string encrypted_radix64_string ;
|
||||
std::string destination_pgp_id ;
|
||||
RsPgpId destination_pgp_id ;
|
||||
uint32_t time_of_validity ;
|
||||
uint32_t last_hit_time ;
|
||||
uint32_t flags ;
|
||||
|
|
@ -545,7 +546,7 @@ class RsMsgSrcId : public RsMessageItem
|
|||
//
|
||||
|
||||
uint32_t msgId;
|
||||
std::string srcId;
|
||||
RsPeerId srcId;
|
||||
};
|
||||
class RsPublicMsgInviteConfigItem : public RsMessageItem
|
||||
{
|
||||
|
|
|
|||
|
|
@ -203,9 +203,9 @@ bool RsNxsSerialiser::serialiseNxsSynMsgItem(RsNxsSyncMsgItem *item, void *data,
|
|||
|
||||
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
|
||||
ok &= setRawUInt8(data, *size, &offset, item->flag);
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId);
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->authorId);
|
||||
ok &= item->grpId.serialise(data, *size, offset);
|
||||
ok &= item->msgId.serialise(data, *size, offset);
|
||||
ok &= item->authorId.serialise(data, *size, offset);
|
||||
|
||||
if(offset != tlvsize){
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
|
|
@ -253,8 +253,8 @@ bool RsNxsSerialiser::serialiseNxsMsg(RsNxsMsg *item, void *data, uint32_t *size
|
|||
|
||||
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
|
||||
ok &= setRawUInt8(data, *size, &offset, item->pos);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->msgId);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->msgId.serialise(data, *size, offset);
|
||||
ok &= item->grpId.serialise(data, *size, offset);
|
||||
ok &= item->msg.SetTlv(data, tlvsize, &offset);
|
||||
ok &= item->meta.SetTlv(data, *size, &offset);
|
||||
|
||||
|
|
@ -305,7 +305,7 @@ bool RsNxsSerialiser::serialiseNxsGrp(RsNxsGrp *item, void *data, uint32_t *size
|
|||
// grp id
|
||||
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
|
||||
ok &= setRawUInt8(data, *size, &offset, item->pos);
|
||||
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->grpId.serialise(data, *size, offset);
|
||||
ok &= item->grp.SetTlv(data, tlvsize, &offset);
|
||||
ok &= item->meta.SetTlv(data, *size, &offset);
|
||||
|
||||
|
|
@ -454,9 +454,9 @@ bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data
|
|||
|
||||
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
|
||||
ok &= setRawUInt8(data, *size, &offset, item->flag);
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->grpId.serialise(data, *size, offset);
|
||||
ok &= setRawUInt32(data, *size, &offset, item->publishTs);
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->authorId);
|
||||
ok &= item->authorId.serialise(data, *size, offset);
|
||||
|
||||
if(offset != tlvsize){
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
|
|
@ -504,7 +504,7 @@ bool RsNxsSerialiser::serialiseNxsSyncMsg(RsNxsSyncMsg *item, void *data, uint32
|
|||
ok &= setRawUInt8(data, *size, &offset, item->flag);
|
||||
ok &= setRawUInt32(data, *size, &offset, item->createdSince);
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash);
|
||||
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->grpId.serialise(data, *size, offset);
|
||||
ok &= setRawUInt32(data, *size, &offset, item->updateTS);
|
||||
|
||||
if(offset != tlvsize){
|
||||
|
|
@ -574,7 +574,7 @@ RsNxsGrp* RsNxsSerialiser::deserialNxsGrp(void *data, uint32_t *size){
|
|||
|
||||
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
|
||||
ok &= getRawUInt8(data, *size, &offset, &(item->pos));
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->grpId.deserialise(data, *size, offset);
|
||||
ok &= item->grp.GetTlv(data, *size, &offset);
|
||||
ok &= item->meta.GetTlv(data, *size, &offset);
|
||||
|
||||
|
|
@ -643,8 +643,8 @@ RsNxsMsg* RsNxsSerialiser::deserialNxsMsg(void *data, uint32_t *size){
|
|||
|
||||
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
|
||||
ok &= getRawUInt8(data, *size, &offset, &(item->pos));
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId);
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
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);
|
||||
|
||||
|
|
@ -780,9 +780,9 @@ RsNxsSyncGrpItem* RsNxsSerialiser::deserialNxsSyncGrpItem(void *data, uint32_t *
|
|||
|
||||
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
|
||||
ok &= getRawUInt8(data, *size, &offset, &(item->flag));
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->grpId.deserialise(data, *size, offset);
|
||||
ok &= getRawUInt32(data, *size, &offset, &(item->publishTs));
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->authorId);
|
||||
ok &= item->authorId.deserialise(data, *size, offset);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
|
|
@ -916,9 +916,9 @@ RsNxsSyncMsgItem* RsNxsSerialiser::deserialNxsSyncMsgItem(void *data, uint32_t *
|
|||
|
||||
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
|
||||
ok &= getRawUInt8(data, *size, &offset, &(item->flag));
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId);
|
||||
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->authorId);
|
||||
ok &= item->grpId.deserialise(data, *size, offset);
|
||||
ok &= item->msgId.deserialise(data, *size, offset);
|
||||
ok &= item->authorId.deserialise(data, *size, offset);
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
|
|
@ -989,7 +989,7 @@ RsNxsSyncMsg* RsNxsSerialiser::deserialNxsSyncMsg(void *data, uint32_t *size)
|
|||
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 &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
|
||||
ok &= item->grpId.deserialise(data, *size, offset);
|
||||
ok &= getRawUInt32(data, *size, &offset, &(item->updateTS));
|
||||
|
||||
if (offset != rssize)
|
||||
|
|
@ -1031,8 +1031,8 @@ uint32_t RsNxsSerialiser::sizeNxsMsg(RsNxsMsg *item)
|
|||
|
||||
s += 4; // transaction number
|
||||
s += 1; // pos
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += GetTlvStringSize(item->msgId);
|
||||
s += item->grpId.serial_size();
|
||||
s += item->msgId.serial_size();
|
||||
s += item->msg.TlvSize();
|
||||
s += item->meta.TlvSize();
|
||||
|
||||
|
|
@ -1045,7 +1045,7 @@ uint32_t RsNxsSerialiser::sizeNxsGrp(RsNxsGrp *item)
|
|||
|
||||
s += 4; // transaction number
|
||||
s += 1; // pos
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += item->grpId.serial_size();
|
||||
s += item->grp.TlvSize();
|
||||
s += item->meta.TlvSize();
|
||||
|
||||
|
|
@ -1074,8 +1074,8 @@ uint32_t RsNxsSerialiser::sizeNxsSyncGrpItem(RsNxsSyncGrpItem *item)
|
|||
s += 4; // transaction number
|
||||
s += 4; // publishTs
|
||||
s += 1; // flag
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += GetTlvStringSize(item->authorId);
|
||||
s += item->grpId.serial_size();
|
||||
s += item->authorId.serial_size();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
|
@ -1089,7 +1089,7 @@ uint32_t RsNxsSerialiser::sizeNxsSyncMsg(RsNxsSyncMsg *item)
|
|||
s += 4; // transaction number
|
||||
s += 1; // flag
|
||||
s += 4; // age
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += item->grpId.serial_size();
|
||||
s += GetTlvStringSize(item->syncHash);
|
||||
s += 4; // updateTS
|
||||
|
||||
|
|
@ -1103,9 +1103,9 @@ uint32_t RsNxsSerialiser::sizeNxsSyncMsgItem(RsNxsSyncMsgItem *item)
|
|||
|
||||
s += 4; // transaction number
|
||||
s += 1; // flag
|
||||
s += GetTlvStringSize(item->grpId);
|
||||
s += GetTlvStringSize(item->msgId);
|
||||
s += GetTlvStringSize(item->authorId);
|
||||
s += item->grpId.serial_size();
|
||||
s += item->msgId.serial_size();
|
||||
s += item->authorId.serial_size();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -178,8 +178,8 @@ public:
|
|||
uint32_t publishTs; // to compare to Ts of receiving peer's grp of same id
|
||||
|
||||
/// grpId of grp held by sending peer
|
||||
std::string grpId;
|
||||
std::string authorId;
|
||||
RsGxsGroupId grpId;
|
||||
RsGxsId authorId;
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -204,7 +204,7 @@ public:
|
|||
virtual void clear();
|
||||
virtual std::ostream &print(std::ostream &out, uint16_t indent);
|
||||
|
||||
std::string grpId; /// group Id, needed to complete version Id (ncvi)
|
||||
RsGxsGroupId grpId; /// group Id, needed to complete version Id (ncvi)
|
||||
static int refcount;
|
||||
RsTlvBinaryData grp; /// actual group data
|
||||
uint8_t pos; /// used for splitting up grp
|
||||
|
|
@ -237,7 +237,7 @@ public:
|
|||
virtual void clear();
|
||||
virtual std::ostream &print(std::ostream &out, uint16_t indent);
|
||||
|
||||
std::string grpId;
|
||||
RsGxsGroupId grpId;
|
||||
uint8_t flag;
|
||||
uint32_t createdSince;
|
||||
uint32_t updateTS; // time of last update
|
||||
|
|
@ -261,9 +261,9 @@ public:
|
|||
virtual std::ostream &print(std::ostream &out, uint16_t indent);
|
||||
|
||||
uint8_t flag; // response/req
|
||||
std::string grpId;
|
||||
std::string msgId;
|
||||
std::string authorId;
|
||||
RsGxsGroupId grpId;
|
||||
RsGxsMessageId msgId;
|
||||
RsGxsId authorId;
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -295,8 +295,8 @@ public:
|
|||
|
||||
uint8_t pos; /// used for splitting up msg
|
||||
uint8_t count; /// number of split up messages
|
||||
std::string grpId; /// group id, forms part of version id
|
||||
std::string msgId; /// msg id
|
||||
RsGxsGroupId grpId; /// group id, forms part of version id
|
||||
RsGxsMessageId msgId; /// msg id
|
||||
static int refcount;
|
||||
|
||||
/*!
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ std::ostream& RsPluginHashSetItem::print(std::ostream& o, uint16_t)
|
|||
o << "Item type: RsPluginHashSetItem" << std::endl;
|
||||
o << " Hash list: " << std::endl;
|
||||
|
||||
for(std::list<std::string>::const_iterator it(hashes.ids.begin());it!=hashes.ids.end();++it)
|
||||
for(std::list<Sha1CheckSum>::const_iterator it(hashes.ids.begin());it!=hashes.ids.end();++it)
|
||||
o << " " << *it << std::endl;
|
||||
|
||||
return o ;
|
||||
|
|
|
|||
|
|
@ -34,6 +34,8 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "retroshare/rstypes.h"
|
||||
|
||||
/*******************************************************************
|
||||
* This is the Top-Level serialiser/deserialise,
|
||||
*
|
||||
|
|
@ -84,8 +86,8 @@ class RsItem: public RsMemoryManagement::SmallObject
|
|||
void print_string(std::string &out, uint16_t indent = 0);
|
||||
|
||||
/* source / destination id */
|
||||
const std::string& PeerId() const { return peerId; }
|
||||
void PeerId(const std::string& id) { peerId = id; }
|
||||
const RsPeerId& PeerId() const { return peerId; }
|
||||
void PeerId(const RsPeerId& id) { peerId = id; }
|
||||
|
||||
/* complete id */
|
||||
uint32_t PacketId() const;
|
||||
|
|
@ -104,7 +106,7 @@ class RsItem: public RsMemoryManagement::SmallObject
|
|||
inline void setPriorityLevel(uint8_t l) { _priority_level = l ;}
|
||||
private:
|
||||
uint32_t type;
|
||||
std::string peerId;
|
||||
RsPeerId peerId;
|
||||
uint8_t _priority_level ;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ RsTlvFileItem::RsTlvFileItem()
|
|||
void RsTlvFileItem::TlvClear()
|
||||
{
|
||||
filesize = 0;
|
||||
hash = "";
|
||||
hash.clear() ;
|
||||
name.clear();
|
||||
path.clear();
|
||||
pop = 0;
|
||||
|
|
@ -56,7 +56,7 @@ uint32_t RsTlvFileItem::TlvSize()
|
|||
{
|
||||
uint32_t s = TLV_HEADER_SIZE; /* header */
|
||||
s += 8; /* filesize */
|
||||
s += GetTlvStringSize(hash);
|
||||
s += hash.serial_size() ;
|
||||
#ifdef TLV_FI_DEBUG
|
||||
std::cerr << "RsTlvFileItem::TlvSize() 8 + Hash: " << s << std::endl;
|
||||
#endif
|
||||
|
|
@ -163,7 +163,7 @@ bool RsTlvFileItem::SetTlv(void *data, uint32_t size, uint32_t *offset)
|
|||
std::cerr << std::endl;
|
||||
#endif
|
||||
|
||||
ok &= SetTlvString(data, tlvend, offset, TLV_TYPE_STR_HASH_SHA1, hash);
|
||||
ok &= hash.serialise(data, tlvend, *offset) ;
|
||||
|
||||
|
||||
#ifdef TLV_FI_DEBUG
|
||||
|
|
@ -285,7 +285,7 @@ bool RsTlvFileItem::GetTlv(void *data, uint32_t size, uint32_t *offset)
|
|||
|
||||
/* get mandatory parts first */
|
||||
ok &= getRawUInt64(data, tlvend, offset, &filesize);
|
||||
ok &= GetTlvString(data, tlvend, offset, TLV_TYPE_STR_HASH_SHA1, hash);
|
||||
ok &= hash.deserialise(data, tlvend, *offset) ;
|
||||
|
||||
/* while there is more TLV (optional part) */
|
||||
while((*offset) + 2 < tlvend)
|
||||
|
|
|
|||
|
|
@ -245,15 +245,42 @@ std::ostream &RsTlvBinaryData::print(std::ostream &out, uint16_t indent)
|
|||
|
||||
/************************************* Peer Id Set ************************************/
|
||||
|
||||
RsTlvPeerIdSet::RsTlvPeerIdSet(): RsTlvStringSet(TLV_TYPE_PEERSET) {}
|
||||
RsTlvHashSet::RsTlvHashSet(): RsTlvStringSet(TLV_TYPE_HASHSET) {}
|
||||
RsTlvPgpIdSet::RsTlvPgpIdSet(): RsTlvStringSet(TLV_TYPE_PGPIDSET) {}
|
||||
|
||||
|
||||
RsTlvStringSet::RsTlvStringSet(uint16_t type) :mType(type)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool RsTlvStringSet::SetTlv(void *data, uint32_t size, uint32_t *offset) /* serialise */
|
||||
{
|
||||
/* 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, mType , tlvsize);
|
||||
|
||||
/* determine the total size of ids strings in list */
|
||||
|
||||
std::list<std::string>::iterator it;
|
||||
|
||||
for(it = ids.begin(); it != ids.end() ; ++it)
|
||||
{
|
||||
if (it->length() > 0)
|
||||
ok &= SetTlvString(data, tlvend, offset, TLV_TYPE_STR_GENID, *it);
|
||||
}
|
||||
|
||||
return ok;
|
||||
|
||||
}
|
||||
|
||||
|
||||
void RsTlvStringSet::TlvClear()
|
||||
{
|
||||
ids.clear();
|
||||
|
|
@ -268,7 +295,7 @@ uint32_t RsTlvStringSet::TlvSize()
|
|||
/* determine the total size of ids strings in list */
|
||||
|
||||
std::list<std::string>::iterator it;
|
||||
|
||||
|
||||
for(it = ids.begin(); it != ids.end() ; ++it)
|
||||
{
|
||||
if (it->length() > 0)
|
||||
|
|
@ -279,36 +306,6 @@ uint32_t RsTlvStringSet::TlvSize()
|
|||
}
|
||||
|
||||
|
||||
bool RsTlvStringSet::SetTlv(void *data, uint32_t size, uint32_t *offset) /* serialise */
|
||||
{
|
||||
/* 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, mType , tlvsize);
|
||||
|
||||
/* determine the total size of ids strings in list */
|
||||
|
||||
std::list<std::string>::iterator it;
|
||||
|
||||
for(it = ids.begin(); it != ids.end() ; ++it)
|
||||
{
|
||||
if (it->length() > 0)
|
||||
ok &= SetTlvString(data, tlvend, offset, TLV_TYPE_STR_GENID, *it);
|
||||
}
|
||||
|
||||
return ok;
|
||||
|
||||
}
|
||||
|
||||
|
||||
bool RsTlvStringSet::GetTlv(void *data, uint32_t size, uint32_t *offset) /* serialise */
|
||||
{
|
||||
if (size < *offset + TLV_HEADER_SIZE)
|
||||
|
|
|
|||
|
|
@ -37,6 +37,10 @@
|
|||
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <retroshare/rstypes.h>
|
||||
#include <serialiser/rstlvtypes.h>
|
||||
#include <serialiser/rstlvbase.h>
|
||||
#include <serialiser/rsbaseserial.h>
|
||||
|
||||
|
||||
//! A base class for all tlv items
|
||||
|
|
@ -112,23 +116,82 @@ virtual std::ostream &printHex(std::ostream &out, uint16_t indent); /* SPECIAL O
|
|||
std::list<std::string> ids; /* Mandatory */
|
||||
};
|
||||
|
||||
class RsTlvPeerIdSet: public RsTlvStringSet
|
||||
template<class ID_CLASS,uint32_t TLV_TYPE> class t_RsTlvIdSet: public RsTlvItem
|
||||
{
|
||||
public:
|
||||
RsTlvPeerIdSet();
|
||||
t_RsTlvIdSet() {}
|
||||
virtual ~t_RsTlvIdSet() {}
|
||||
|
||||
virtual uint32_t TlvSize() { return ID_CLASS::SIZE_IN_BYTES * ids.size() + TLV_HEADER_SIZE; }
|
||||
virtual void TlvClear(){ ids.clear() ; }
|
||||
virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset) /* serialise */
|
||||
{ /* 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 = ok && SetTlvBase(data, tlvend, offset, TLV_TYPE, tlvsize);
|
||||
|
||||
for(typename std::list<ID_CLASS>::const_iterator it(ids.begin());it!=ids.end();++it)
|
||||
ok = ok && (*it).serialise(data,size,*offset) ;
|
||||
|
||||
return ok ;
|
||||
}
|
||||
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset) /* deserialise */
|
||||
{
|
||||
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 != TLV_TYPE) /* check type */
|
||||
return false;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
TlvClear();
|
||||
|
||||
/* skip the header */
|
||||
(*offset) += TLV_HEADER_SIZE;
|
||||
|
||||
while(*offset + ID_CLASS::SIZE_IN_BYTES <= tlvend)
|
||||
{
|
||||
ID_CLASS id ;
|
||||
ok = ok && id.deserialise(data,size,*offset) ;
|
||||
ids.push_back(id) ;
|
||||
}
|
||||
if(*offset != tlvend)
|
||||
std::cerr << "(EE) deserialisaiton error in " << __PRETTY_FUNCTION__ << std::endl;
|
||||
return *offset == tlvend ;
|
||||
}
|
||||
virtual std::ostream &print(std::ostream &out, uint16_t indent)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": not implemented" << std::endl;
|
||||
return out ;
|
||||
}
|
||||
virtual std::ostream &printHex(std::ostream &out, uint16_t indent) /* SPECIAL One */
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": not implemented" << std::endl;
|
||||
return out ;
|
||||
}
|
||||
|
||||
std::list<ID_CLASS> ids ;
|
||||
};
|
||||
|
||||
class RsTlvHashSet: public RsTlvStringSet
|
||||
{
|
||||
public:
|
||||
RsTlvHashSet();
|
||||
};
|
||||
|
||||
class RsTlvPgpIdSet: public RsTlvStringSet
|
||||
{
|
||||
public:
|
||||
RsTlvPgpIdSet();
|
||||
};
|
||||
typedef t_RsTlvIdSet<RsPeerId,TLV_TYPE_PEERSET> RsTlvPeerIdSet ;
|
||||
typedef t_RsTlvIdSet<RsPgpId,TLV_TYPE_PGPIDSET> RsTlvPgpIdSet ;
|
||||
typedef t_RsTlvIdSet<Sha1CheckSum,TLV_TYPE_HASHSET> RsTlvHashSet ;
|
||||
|
||||
class RsTlvServiceIdSet: public RsTlvItem
|
||||
{
|
||||
|
|
@ -180,7 +243,7 @@ virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deseria
|
|||
virtual std::ostream &print(std::ostream &out, uint16_t indent);
|
||||
|
||||
uint64_t filesize; /// Mandatory: size of file to be downloaded
|
||||
std::string hash; /// Mandatory: to find file
|
||||
RsFileHash hash; /// Mandatory: to find file
|
||||
std::string name; /// Optional: name of file
|
||||
std::string path; /// Optional: path on host computer
|
||||
uint32_t pop; /// Optional: Popularity of file
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue