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

Fixed serialiser bug in RsTlvList

Browse source 
Switched to proper Ids in gxsCircle gxsId items.
Fixed up Config serialiser.



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@7218 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2014-04-01 08:00:20 +00:00
parent acba05b780
commit 0dbe55bd05
12 changed files with 101 additions and 170 deletions
Download patch file Download diff file Expand all files Collapse all files

25
libretroshare/src/pqi/p3peermgr.cc
View file

@ -1475,9 +1475,10 @@ bool p3PeerMgrIMPL::saveList(bool &cleanup, std::list<RsItem *>& saveData)
RsPeerNetItem *item = new RsPeerNetItem(); RsPeerNetItem *item = new RsPeerNetItem();
item->clear(); item->clear();
item->pid = getOwnId().toStdString(); item->peerId = getOwnId();
item->gpg_id = mOwnState.gpg_id.toStdString(); item->pgpId = mOwnState.gpg_id;
item->location = mOwnState.location; item->location = mOwnState.location;
#if 0 #if 0
if (mOwnState.netMode & RS_NET_MODE_TRY_EXT) if (mOwnState.netMode & RS_NET_MODE_TRY_EXT)
{ {
@ -1526,8 +1527,8 @@ bool p3PeerMgrIMPL::saveList(bool &cleanup, std::list<RsItem *>& saveData)
item = new RsPeerNetItem(); item = new RsPeerNetItem();
item->clear(); item->clear();
item->pid = it->first.toStdString(); item->peerId = it->first;
item->gpg_id = (it->second).gpg_id.toStdString(); item->pgpId = (it->second).gpg_id;
item->location = (it->second).location; item->location = (it->second).location;
item->netMode = (it->second).netMode; item->netMode = (it->second).netMode;
item->vs_disc = (it->second).vs_disc; item->vs_disc = (it->second).vs_disc;
@ -1643,8 +1644,8 @@ bool p3PeerMgrIMPL::loadList(std::list<RsItem *>& load)
RsPeerNetItem *pitem = dynamic_cast<RsPeerNetItem *>(*it); RsPeerNetItem *pitem = dynamic_cast<RsPeerNetItem *>(*it);
if (pitem) if (pitem)
{ {
RsPeerId peer_id(pitem->pid) ; RsPeerId peer_id = pitem->peerId ;
RsPgpId peer_pgp_id(pitem->gpg_id) ; RsPgpId peer_pgp_id = pitem->pgpId ;
if (peer_id == ownId) if (peer_id == ownId)
{ {
@ -1669,7 +1670,7 @@ bool p3PeerMgrIMPL::loadList(std::list<RsItem *>& load)
#endif #endif
/* ************* */ /* ************* */
addFriend(peer_id, peer_pgp_id, pitem->netMode, pitem->vs_disc, pitem->vs_dht, pitem->lastContact, RS_SERVICE_PERM_ALL); addFriend(peer_id, peer_pgp_id, pitem->netMode, pitem->vs_disc, pitem->vs_dht, pitem->lastContact, RS_SERVICE_PERM_ALL);
setLocation(RsPeerId(pitem->pid), pitem->location); setLocation(pitem->peerId, pitem->location);
} }
if (pitem->netMode == RS_NET_MODE_HIDDEN) if (pitem->netMode == RS_NET_MODE_HIDDEN)
@ -2044,15 +2045,15 @@ bool p3PeerMgrIMPL::assignPeersToGroup(const std::string &groupId, const std::li
std::list<RsPgpId>::const_iterator peerIt; std::list<RsPgpId>::const_iterator peerIt;
for (peerIt = peerIds.begin(); peerIt != peerIds.end(); peerIt++) { for (peerIt = peerIds.begin(); peerIt != peerIds.end(); peerIt++) {
std::list<RsPgpId>::iterator peerIt1 = std::find(groupItem->peerIds.begin(), groupItem->peerIds.end(), *peerIt); std::list<RsPgpId>::iterator peerIt1 = std::find(groupItem->pgpList.ids.begin(), groupItem->pgpList.ids.end(), *peerIt);
if (assign) { if (assign) {
if (peerIt1 == groupItem->peerIds.end()) { if (peerIt1 == groupItem->pgpList.ids.end()) {
groupItem->peerIds.push_back(*peerIt); groupItem->pgpList.ids.push_back(*peerIt);
changed = true; changed = true;
} }
} else { } else {
if (peerIt1 != groupItem->peerIds.end()) { if (peerIt1 != groupItem->pgpList.ids.end()) {
groupItem->peerIds.erase(peerIt1); groupItem->pgpList.ids.erase(peerIt1);
changed = true; changed = true;
} }
} }

6
libretroshare/src/retroshare/rsidentity.h
View file

@ -96,8 +96,10 @@ class RsGxsIdGroup
// Actually PgpIdHash is SHA1(.mMeta.mGroupId + PGPHandler->GpgFingerprint(ownId)) // Actually PgpIdHash is SHA1(.mMeta.mGroupId + PGPHandler->GpgFingerprint(ownId))
// ??? 160 bits. // ??? 160 bits.
std::string mPgpIdHash; Sha1CheckSum mPgpIdHash;
std::string mPgpIdSign; // Need a signature as proof - otherwise anyone could add others Hashes. // Need a signature as proof - otherwise anyone could add others Hashes.
// This is a string, as the length is variable.
std::string mPgpIdSign;
// Recognition Strings. MAX# defined above. // Recognition Strings. MAX# defined above.
std::list<std::string> mRecognTags; std::list<std::string> mRecognTags;

79
libretroshare/src/serialiser/rsconfigitems.cc
View file

@ -775,8 +775,8 @@ RsPeerNetItem::~RsPeerNetItem()
void RsPeerNetItem::clear() void RsPeerNetItem::clear()
{ {
pid.clear(); peerId.clear();
gpg_id.clear(); pgpId.clear();
location.clear(); location.clear();
netMode = 0; netMode = 0;
vs_disc = 0; vs_disc = 0;
@ -803,10 +803,10 @@ std::ostream &RsPeerNetItem::print(std::ostream &out, uint16_t indent)
uint16_t int_Indent = indent + 2; uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent); printIndent(out, int_Indent);
out << "PeerId: " << pid << std::endl; out << "PeerId: " << peerId.toStdString() << std::endl;
printIndent(out, int_Indent); printIndent(out, int_Indent);
out << "GPGid: " << gpg_id << std::endl; out << "PgpId: " << pgpId.toStdString() << std::endl;
printIndent(out, int_Indent); printIndent(out, int_Indent);
out << "location: " << location << std::endl; out << "location: " << location << std::endl;
@ -845,6 +845,9 @@ std::ostream &RsPeerNetItem::print(std::ostream &out, uint16_t indent)
localAddrList.print(out, int_Indent); localAddrList.print(out, int_Indent);
extAddrList.print(out, int_Indent); extAddrList.print(out, int_Indent);
printIndent(out, int_Indent);
out << "DomainAddr: " << domain_addr;
out << ":" << domain_port << std::endl;
printRsItemEnd(out, "RsPeerNetItem", indent); printRsItemEnd(out, "RsPeerNetItem", indent);
return out; return out;
} }
@ -854,8 +857,8 @@ std::ostream &RsPeerNetItem::print(std::ostream &out, uint16_t indent)
uint32_t RsPeerConfigSerialiser::sizeNet(RsPeerNetItem *i) uint32_t RsPeerConfigSerialiser::sizeNet(RsPeerNetItem *i)
{ {
uint32_t s = 8; /* header */ uint32_t s = 8; /* header */
s += GetTlvStringSize(i->pid); /* peerid */ s += RsPeerId::SIZE_IN_BYTES;
s += GetTlvStringSize(i->gpg_id); s += RsPgpId::SIZE_IN_BYTES;
s += GetTlvStringSize(i->location); s += GetTlvStringSize(i->location);
s += 4; /* netMode */ s += 4; /* netMode */
s += 2; /* vs_disc */ s += 2; /* vs_disc */
@ -914,19 +917,18 @@ bool RsPeerConfigSerialiser::serialiseNet(RsPeerNetItem *item, void *data, uint3
offset += 8; offset += 8;
/* add mandatory parts first */ /* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */ ok &= item->peerId.serialise(data, tlvsize, offset);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GPGID, item->gpg_id); /* Mandatory */ ok &= item->pgpId.serialise(data, tlvsize, offset);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */ ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->netMode); /* Mandatory */ ok &= setRawUInt32(data, tlvsize, &offset, item->netMode); /* Mandatory */
ok &= setRawUInt16(data, tlvsize, &offset, item->vs_disc); /* Mandatory */ ok &= setRawUInt16(data, tlvsize, &offset, item->vs_disc); /* Mandatory */
ok &= setRawUInt16(data, tlvsize, &offset, item->vs_dht); /* Mandatory */ ok &= setRawUInt16(data, tlvsize, &offset, item->vs_dht); /* Mandatory */
ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */ ok &= setRawUInt32(data, tlvsize, &offset, item->lastContact); /* Mandatory */
ok &= item->localAddrV4.SetTlv(data, tlvsize, &offset); ok &= item->localAddrV4.SetTlv(data, tlvsize, &offset);
ok &= item->extAddrV4.SetTlv(data, tlvsize, &offset); ok &= item->extAddrV4.SetTlv(data, tlvsize, &offset);
ok &= item->localAddrV6.SetTlv(data, tlvsize, &offset); ok &= item->localAddrV6.SetTlv(data, tlvsize, &offset);
ok &= item->extAddrV6.SetTlv(data, tlvsize, &offset); ok &= item->extAddrV6.SetTlv(data, tlvsize, &offset);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_DYNDNS, item->dyndns);
ok &= item->localAddrList.SetTlv(data, tlvsize, &offset); ok &= item->localAddrList.SetTlv(data, tlvsize, &offset);
@ -938,10 +940,10 @@ bool RsPeerConfigSerialiser::serialiseNet(RsPeerNetItem *item, void *data, uint3
if(offset != tlvsize) if(offset != tlvsize)
{ {
ok = false;
#ifdef RSSERIAL_ERROR_DEBUG #ifdef RSSERIAL_ERROR_DEBUG
std::cerr << "RsPeerConfigSerialiser::serialiseNet() Size Error! " << std::endl; std::cerr << "RsPeerConfigSerialiser::serialiseNet() Size Error! " << std::endl;
#endif #endif
ok = false;
} }
return ok; return ok;
@ -992,8 +994,8 @@ RsPeerNetItem *RsPeerConfigSerialiser::deserialiseNet(void *data, uint32_t *size
offset += 8; offset += 8;
/* get mandatory parts first */ /* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->pid); /* Mandatory */ ok &= item->peerId.deserialise(data, rssize, offset);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_GPGID, item->gpg_id); /* Mandatory */ ok &= item->pgpId.deserialise(data, rssize, offset);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */ ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_LOCATION, item->location); /* Mandatory */
ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */ ok &= getRawUInt32(data, rssize, &offset, &(item->netMode)); /* Mandatory */
ok &= getRawUInt16(data, rssize, &offset, &(item->vs_disc)); /* Mandatory */ ok &= getRawUInt16(data, rssize, &offset, &(item->vs_disc)); /* Mandatory */
@ -1009,14 +1011,6 @@ RsPeerNetItem *RsPeerConfigSerialiser::deserialiseNet(void *data, uint32_t *size
ok &= item->localAddrList.GetTlv(data, rssize, &offset); ok &= item->localAddrList.GetTlv(data, rssize, &offset);
ok &= item->extAddrList.GetTlv(data, rssize, &offset); ok &= item->extAddrList.GetTlv(data, rssize, &offset);
// Allow acceptance of old format.
if (offset == rssize)
{
std::cerr << "RsPeerConfigSerialiser::deserialiseNet() Accepting Old format PeerNetItem" << std::endl;
return item;
}
// New for V0.6. // New for V0.6.
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DOMADDR, item->domain_addr); ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_DOMADDR, item->domain_addr);
ok &= getRawUInt16(data, rssize, &offset, &(item->domain_port)); /* Mandatory */ ok &= getRawUInt16(data, rssize, &offset, &(item->domain_port)); /* Mandatory */
@ -1167,7 +1161,7 @@ void RsPeerGroupItem::clear()
id.clear(); id.clear();
name.clear(); name.clear();
flag = 0; flag = 0;
peerIds.clear(); pgpList.ids.clear();
} }
std::ostream &RsPeerGroupItem::print(std::ostream &out, uint16_t indent) std::ostream &RsPeerGroupItem::print(std::ostream &out, uint16_t indent)
@ -1185,9 +1179,9 @@ std::ostream &RsPeerGroupItem::print(std::ostream &out, uint16_t indent)
out << "groupFlag: " << flag << std::endl; out << "groupFlag: " << flag << std::endl;
std::list<RsPgpId>::iterator it; std::list<RsPgpId>::iterator it;
for (it = peerIds.begin(); it != peerIds.end(); it++) { for (it = pgpList.ids.begin(); it != pgpList.ids.end(); it++) {
printIndent(out, int_Indent); printIndent(out, int_Indent);
out << "peerId: " << *it << std::endl; out << "peerId: " << it->toStdString() << std::endl;
} }
printRsItemEnd(out, "RsPeerGroupItem", indent); printRsItemEnd(out, "RsPeerGroupItem", indent);
@ -1200,7 +1194,7 @@ void RsPeerGroupItem::set(RsGroupInfo &groupInfo)
id = groupInfo.id; id = groupInfo.id;
name = groupInfo.name; name = groupInfo.name;
flag = groupInfo.flag; flag = groupInfo.flag;
peerIds = groupInfo.peerIds; pgpList.ids = groupInfo.peerIds;
} }
/* get data from RsGroupInfo to RsPeerGroupItem */ /* get data from RsGroupInfo to RsPeerGroupItem */
@ -1209,7 +1203,7 @@ void RsPeerGroupItem::get(RsGroupInfo &groupInfo)
groupInfo.id = id; groupInfo.id = id;
groupInfo.name = name; groupInfo.name = name;
groupInfo.flag = flag; groupInfo.flag = flag;
groupInfo.peerIds = peerIds; groupInfo.peerIds = pgpList.ids;
} }
/*************************************************************************/ /*************************************************************************/
@ -1221,12 +1215,7 @@ uint32_t RsPeerConfigSerialiser::sizeGroup(RsPeerGroupItem *i)
s += GetTlvStringSize(i->id); s += GetTlvStringSize(i->id);
s += GetTlvStringSize(i->name); s += GetTlvStringSize(i->name);
s += 4; /* flag */ s += 4; /* flag */
s += i->pgpList.TlvSize();
std::list<RsPgpId>::iterator it;
for (it = i->peerIds.begin(); it != i->peerIds.end(); it++) {
s += RsPgpId::SIZE_IN_BYTES ;
}
return s; return s;
} }
@ -1259,11 +1248,7 @@ bool RsPeerConfigSerialiser::serialiseGroup(RsPeerGroupItem *item, void *data, u
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_KEY, item->id); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_KEY, item->id);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name);
ok &= setRawUInt32(data, tlvsize, &offset, item->flag); ok &= setRawUInt32(data, tlvsize, &offset, item->flag);
ok &= item->pgpList.SetTlv(data, tlvsize, &offset);
std::list<RsPgpId>::iterator it;
for (it = item->peerIds.begin(); it != item->peerIds.end(); it++) {
ok &= (*it).serialise(data, tlvsize, offset) ;
}
if(offset != tlvsize) if(offset != tlvsize)
{ {
@ -1312,13 +1297,7 @@ RsPeerGroupItem *RsPeerConfigSerialiser::deserialiseGroup(void *data, uint32_t *
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_KEY, item->id); ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_KEY, item->id);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name); ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name);
ok &= getRawUInt32(data, rssize, &offset, &(item->flag)); ok &= getRawUInt32(data, rssize, &offset, &(item->flag));
ok &= item->pgpList.GetTlv(data, rssize, &offset);
RsPgpId peerId;
while (offset != rssize)
{
ok &= peerId.deserialise(data, rssize, offset) ;
item->peerIds.push_back(peerId);
}
if (offset != rssize) if (offset != rssize)
{ {
@ -1529,12 +1508,12 @@ uint32_t RsCacheConfigSerialiser::size(RsItem *i)
uint32_t s = 8; // to store calculated size, initiailize with size of header uint32_t s = 8; // to store calculated size, initiailize with size of header
s += item->pid.serial_size(); s += item->pid.serial_size();
s += 2; /* cachetypeid */ s += 2; /* cachetypeid */
s += 2; /* cachesubid */ s += 2; /* cachesubid */
s += GetTlvStringSize(item->path); s += GetTlvStringSize(item->path);
s += GetTlvStringSize(item->name); s += GetTlvStringSize(item->name);
s += item->hash.serial_size(); s += item->hash.serial_size();
s += 8; /* size */ s += 8; /* size */
s += 4; /* recvd */ s += 4; /* recvd */
@ -1566,12 +1545,12 @@ bool RsCacheConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *size)
/* add the mandatory parts first */ /* add the mandatory parts first */
ok &= item->pid.serialise(data, tlvsize, offset) ; ok &= item->pid.serialise(data, tlvsize, offset) ;
ok &= setRawUInt16(data, tlvsize, &offset, item->cachetypeid); ok &= setRawUInt16(data, tlvsize, &offset, item->cachetypeid);
ok &= setRawUInt16(data, tlvsize, &offset, item->cachesubid); 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_PATH, item->path);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name);
ok &= item->hash.serialise(data, tlvsize, offset) ; ok &= item->hash.serialise(data, tlvsize, offset) ;
ok &= setRawUInt64(data, tlvsize, &offset, item->size); ok &= setRawUInt64(data, tlvsize, &offset, item->size);
ok &= setRawUInt32(data, tlvsize, &offset, item->recvd); ok &= setRawUInt32(data, tlvsize, &offset, item->recvd);
@ -1619,12 +1598,12 @@ RsItem *RsCacheConfigSerialiser::deserialise(void *data, uint32_t *size)
/* get mandatory parts first */ /* get mandatory parts first */
ok &= item->pid.deserialise(data, rssize, offset) ; ok &= item->pid.deserialise(data, rssize, offset) ;
ok &= getRawUInt16(data, rssize, &offset, &(item->cachetypeid)); ok &= getRawUInt16(data, rssize, &offset, &(item->cachetypeid));
ok &= getRawUInt16(data, rssize, &offset, &(item->cachesubid)); 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_PATH, item->path);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name); ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name);
ok &= item->hash.deserialise(data, rssize, offset) ; ok &= item->hash.deserialise(data, rssize, offset) ;
ok &= getRawUInt64(data, rssize, &offset, &(item->size)); ok &= getRawUInt64(data, rssize, &offset, &(item->size));
ok &= getRawUInt32(data, rssize, &offset, &(item->recvd)); ok &= getRawUInt32(data, rssize, &offset, &(item->recvd));

17
libretroshare/src/serialiser/rsconfigitems.h
View file

@ -37,11 +37,6 @@
#include "serialiser/rstlvkeyvalue.h" #include "serialiser/rstlvkeyvalue.h"
#include "serialiser/rstlvaddrs.h" #include "serialiser/rstlvaddrs.h"
#if 0
#include "serialiser/rstlvbase.h"
#include "serialiser/rstlvtypes.h"
#endif
class RsGroupInfo; class RsGroupInfo;
const uint8_t RS_PKT_TYPE_GENERAL_CONFIG = 0x01; const uint8_t RS_PKT_TYPE_GENERAL_CONFIG = 0x01;
@ -79,9 +74,9 @@ virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0); std::ostream &print(std::ostream &out, uint16_t indent = 0);
/* networking information */ /* networking information */
std::string pid; /* Mandatory */ RsPeerId peerId; /* Mandatory */
std::string gpg_id; /* Mandatory */ RsPgpId pgpId; /* Mandatory */
std::string location; /* not Mandatory */ std::string location; /* Mandatory */
uint32_t netMode; /* Mandatory */ uint32_t netMode; /* Mandatory */
uint16_t vs_disc; /* Mandatory */ uint16_t vs_disc; /* Mandatory */
uint16_t vs_dht; /* Mandatory */ uint16_t vs_dht; /* Mandatory */
@ -119,6 +114,8 @@ class RsPeerServicePermissionItem : public RsItem
std::vector<RsPgpId> pgp_ids ; std::vector<RsPgpId> pgp_ids ;
std::vector<ServicePermissionFlags> service_flags ; std::vector<ServicePermissionFlags> service_flags ;
}; };
class RsPeerGroupItem : public RsItem class RsPeerGroupItem : public RsItem
{ {
public: public:
@ -138,7 +135,7 @@ public:
std::string name; std::string name;
uint32_t flag; uint32_t flag;
std::list<RsPgpId> peerIds; RsTlvPgpIdSet pgpList;
}; };
@ -261,7 +258,7 @@ class RsFileTransfer: public RsItem
RsTlvFileItem file; RsTlvFileItem file;
RsTlvPeerIdSet allPeerIds; RsTlvPeerIdSet allPeerIds;
RsPeerId cPeerId; RsPeerId cPeerId;
uint16_t state; uint16_t state;
uint16_t in; uint16_t in;

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

@ -121,26 +121,14 @@ bool RsGxsCircleGroupItem::convertFrom(const RsGxsCircleGroup &group)
// Enforce the local rules. // Enforce the local rules.
if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL)
{ {
std::list<RsPgpId>::const_iterator it = group.mLocalFriends.begin(); pgpIdSet.ids = group.mLocalFriends;
for(; it != group.mLocalFriends.end(); it++)
pgpIdSet.ids.push_back(it->toStdString());
} }
else else
{ {
std::list<RsGxsId>::const_iterator it = group.mInvitedMembers.begin(); gxsIdSet.ids = group.mInvitedMembers;
for(; it != group.mInvitedMembers.end(); it++)
{
gxsIdSet.ids.push_back(it->toStdString());
}
} }
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());
subCircleSet.ids = group.mSubCircles;
return true; return true;
} }
@ -151,27 +139,14 @@ bool RsGxsCircleGroupItem::convertTo(RsGxsCircleGroup &group) const
// Enforce the local rules. // Enforce the local rules.
if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL) if (meta.mCircleType == GXS_CIRCLE_TYPE_LOCAL)
{ {
std::list<std::string>::const_iterator it = pgpIdSet.ids.begin(); group.mLocalFriends = pgpIdSet.ids;
for(; it != pgpIdSet.ids.end(); it++)
group.mLocalFriends.push_back(RsPgpId(*it));
group.mInvitedMembers.clear();
} }
else 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)));
} }
const std::list<std::string> scs = subCircleSet.ids; group.mSubCircles = 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; return true;
} }

14
libretroshare/src/serialiser/rsgxscircleitems.h
View file

@ -32,6 +32,7 @@
#include "serialiser/rsserial.h" #include "serialiser/rsserial.h"
#include "serialiser/rstlvitem.h" #include "serialiser/rstlvitem.h"
#include "serialiser/rstlvstring.h" #include "serialiser/rstlvstring.h"
#include "serialiser/rstlvidset.h"
#include "rsgxsitems.h" #include "rsgxsitems.h"
#include "retroshare/rsgxscircles.h" #include "retroshare/rsgxscircles.h"
@ -49,10 +50,13 @@ class RsGxsCircleGroupItem : public RsGxsGrpItem
public: public:
RsGxsCircleGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_GXSCIRCLE, RsGxsCircleGroupItem(): RsGxsGrpItem(RS_SERVICE_GXS_TYPE_GXSCIRCLE,
RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM), RS_PKT_SUBTYPE_GXSCIRCLE_GROUP_ITEM)
#if 0
pgpIdSet(GXSCIRCLE_PGPIDSET), pgpIdSet(GXSCIRCLE_PGPIDSET),
gxsIdSet(GXSCIRCLE_GXSIDSET), gxsIdSet(GXSCIRCLE_GXSIDSET),
subCircleSet(GXSCIRCLE_SUBCIRCLESET) { return;} subCircleSet(GXSCIRCLE_SUBCIRCLESET)
#endif
{ return;}
virtual ~RsGxsCircleGroupItem() { return;} virtual ~RsGxsCircleGroupItem() { return;}
void clear(); void clear();
@ -62,9 +66,9 @@ public:
bool convertTo(RsGxsCircleGroup &group) const; bool convertTo(RsGxsCircleGroup &group) const;
// DIFFERENT FROM OTHER ONES, as stupid serialisation otherwise. // DIFFERENT FROM OTHER ONES, as stupid serialisation otherwise.
RsTlvStringSet pgpIdSet; // For Local Groups. RsTlvPgpIdSet pgpIdSet; // For Local Groups.
RsTlvStringSet gxsIdSet; // For External Groups. RsTlvGxsIdSet gxsIdSet; // For External Groups.
RsTlvStringSet subCircleSet; RsTlvGxsCircleIdSet subCircleSet;
}; };
class RsGxsCircleMsgItem : public RsGxsMsgItem class RsGxsCircleMsgItem : public RsGxsMsgItem

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

@ -169,7 +169,7 @@ uint32_t RsGxsIdSerialiser::sizeGxsIdGroupItem(RsGxsIdGroupItem *item)
const RsGxsIdGroup& group = item->group; const RsGxsIdGroup& group = item->group;
uint32_t s = 8; // header uint32_t s = 8; // header
s += GetTlvStringSize(group.mPgpIdHash); s += Sha1CheckSum::SIZE_IN_BYTES;
s += GetTlvStringSize(group.mPgpIdSign); s += GetTlvStringSize(group.mPgpIdSign);
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags); RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags);
@ -203,7 +203,7 @@ bool RsGxsIdSerialiser::serialiseGxsIdGroupItem(RsGxsIdGroupItem *item, void *da
offset += 8; offset += 8;
/* GxsIdGroupItem */ /* GxsIdGroupItem */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_SHA1, item->group.mPgpIdHash); ok &= item->group.mPgpIdHash.serialise(data, tlvsize, offset);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_SIGN, item->group.mPgpIdSign); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_SIGN, item->group.mPgpIdSign);
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags); RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags);
@ -263,7 +263,7 @@ RsGxsIdGroupItem* RsGxsIdSerialiser::deserialiseGxsIdGroupItem(void *data, uint3
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_HASH_SHA1, item->group.mPgpIdHash); ok &= item->group.mPgpIdHash.deserialise(data, rssize, offset);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_SIGN, item->group.mPgpIdSign); ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_SIGN, item->group.mPgpIdSign);
RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags); RsTlvStringSetRef set(TLV_TYPE_RECOGNSET, item->group.mRecognTags);

9
libretroshare/src/serialiser/rstlvaddrs.cc
View file

@ -28,15 +28,6 @@
#include "serialiser/rstlvaddrs.h" #include "serialiser/rstlvaddrs.h"
#include "serialiser/rsbaseserial.h" #include "serialiser/rsbaseserial.h"
#if 0
#include "rstlvtypes.h"
#include "util/rsprint.h"
#include <ostream>
#include <iomanip>
#include <iostream>
#endif
/************************************* RsTlvIpAddress ************************************/ /************************************* RsTlvIpAddress ************************************/
RsTlvIpAddress::RsTlvIpAddress() RsTlvIpAddress::RsTlvIpAddress()

1
libretroshare/src/serialiser/rstlvbase.h
View file

@ -205,6 +205,7 @@ const uint16_t TLV_TYPE_HASHSET = 0x1022;
const uint16_t TLV_TYPE_PGPIDSET = 0x1023; const uint16_t TLV_TYPE_PGPIDSET = 0x1023;
const uint16_t TLV_TYPE_RECOGNSET = 0x1024; const uint16_t TLV_TYPE_RECOGNSET = 0x1024;
const uint16_t TLV_TYPE_GXSIDSET = 0x1025; const uint16_t TLV_TYPE_GXSIDSET = 0x1025;
const uint16_t TLV_TYPE_GXSCIRCLEIDSET= 0x1026;
const uint16_t TLV_TYPE_SERVICESET = 0x1030; const uint16_t TLV_TYPE_SERVICESET = 0x1030;

5
libretroshare/src/serialiser/rstlvidset.h
View file

@ -60,7 +60,7 @@ template<class ID_CLASS,uint32_t TLV_TYPE> class t_RsTlvIdSet: public RsTlvItem
ok = ok && SetTlvBase(data, tlvend, offset, TLV_TYPE, tlvsize); ok = ok && SetTlvBase(data, tlvend, offset, TLV_TYPE, tlvsize);
for(typename std::list<ID_CLASS>::const_iterator it(ids.begin());it!=ids.end();++it) for(typename std::list<ID_CLASS>::const_iterator it(ids.begin());it!=ids.end();++it)
ok = ok && (*it).serialise(data,size,*offset) ; ok = ok && (*it).serialise(data,tlvend,*offset) ;
return ok ; return ok ;
} }
@ -90,7 +90,7 @@ template<class ID_CLASS,uint32_t TLV_TYPE> class t_RsTlvIdSet: public RsTlvItem
while(*offset + ID_CLASS::SIZE_IN_BYTES <= tlvend) while(*offset + ID_CLASS::SIZE_IN_BYTES <= tlvend)
{ {
ID_CLASS id ; ID_CLASS id ;
ok = ok && id.deserialise(data,size,*offset) ; ok = ok && id.deserialise(data,tlvend,*offset) ;
ids.push_back(id) ; ids.push_back(id) ;
} }
if(*offset != tlvend) if(*offset != tlvend)
@ -115,6 +115,7 @@ typedef t_RsTlvIdSet<RsPeerId,TLV_TYPE_PEERSET> RsTlvPeerIdSet ;
typedef t_RsTlvIdSet<RsPgpId,TLV_TYPE_PGPIDSET> RsTlvPgpIdSet ; typedef t_RsTlvIdSet<RsPgpId,TLV_TYPE_PGPIDSET> RsTlvPgpIdSet ;
typedef t_RsTlvIdSet<Sha1CheckSum,TLV_TYPE_HASHSET> RsTlvHashSet ; typedef t_RsTlvIdSet<Sha1CheckSum,TLV_TYPE_HASHSET> RsTlvHashSet ;
typedef t_RsTlvIdSet<RsGxsId,TLV_TYPE_GXSIDSET> RsTlvGxsIdSet ; typedef t_RsTlvIdSet<RsGxsId,TLV_TYPE_GXSIDSET> RsTlvGxsIdSet ;
typedef t_RsTlvIdSet<RsGxsCircleId,TLV_TYPE_GXSCIRCLEIDSET> RsTlvGxsCircleIdSet ;
class RsTlvServiceIdSet: public RsTlvItem class RsTlvServiceIdSet: public RsTlvItem
{ {

21
libretroshare/src/serialiser/rstlvlist.h
View file

@ -30,6 +30,8 @@
#include <list> #include <list>
#define TLV_DEBUG_LIST 1
template<class TLV_CLASS,uint32_t TLV_TYPE> class t_RsTlvList: public RsTlvItem template<class TLV_CLASS,uint32_t TLV_TYPE> class t_RsTlvList: public RsTlvItem
{ {
public: public:
@ -49,12 +51,18 @@ template<class TLV_CLASS,uint32_t TLV_TYPE> class t_RsTlvList: public RsTlvItem
virtual void TlvClear(){ mList.clear(); } virtual void TlvClear(){ mList.clear(); }
virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset) const virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset) const
{ {
/* must check sizes */
uint32_t tlvsize = TlvSize(); uint32_t tlvsize = TlvSize();
uint32_t tlvend = *offset + tlvsize; uint32_t tlvend = *offset + tlvsize;
/* must check sizes */
if (size < tlvend) if (size < tlvend)
{
#ifdef TLV_DEBUG_LIST
std::cerr << "RsTlvList::SetTlv() Not enough size";
std::cerr << std::endl;
#endif
return false; /* not enough space */ return false; /* not enough space */
}
bool ok = true; bool ok = true;
@ -64,15 +72,20 @@ template<class TLV_CLASS,uint32_t TLV_TYPE> class t_RsTlvList: public RsTlvItem
typename std::list<TLV_CLASS>::const_iterator it; typename std::list<TLV_CLASS>::const_iterator it;
for(it = mList.begin();it != mList.end(); ++it) for(it = mList.begin();it != mList.end(); ++it)
{ {
ok &= it->SetTlv(data,tlvsize,offset) ; ok &= it->SetTlv(data,tlvend,offset) ;
} }
return ok ; return ok ;
} }
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset) virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset)
{ {
if (size < *offset + TLV_HEADER_SIZE) if (size < *offset + TLV_HEADER_SIZE)
{
#ifdef TLV_DEBUG_LIST
std::cerr << "RsTlvList::GetTlv() Not enough size";
std::cerr << std::endl;
#endif
return false; return false;
}
uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[*offset]) ); uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[*offset]) );
uint32_t tlvsize = GetTlvSize( &(((uint8_t *) data)[*offset]) ); uint32_t tlvsize = GetTlvSize( &(((uint8_t *) data)[*offset]) );
@ -96,7 +109,7 @@ template<class TLV_CLASS,uint32_t TLV_TYPE> class t_RsTlvList: public RsTlvItem
while(ok && ((*offset) + 6 < tlvend)) while(ok && ((*offset) + 6 < tlvend))
{ {
TLV_CLASS item; TLV_CLASS item;
ok &= item.GetTlv(data,size,offset); ok &= item.GetTlv(data,tlvend,offset);
if (ok) if (ok)
{ {
mList.push_back(item); mList.push_back(item);

51
libretroshare/src/services/p3idservice.cc
View file

@ -42,12 +42,10 @@
* #define DEBUG_IDS 1 * #define DEBUG_IDS 1
* #define DEBUG_RECOGN 1 * #define DEBUG_RECOGN 1
* #define GXSID_GEN_DUMMY_DATA 1 * #define GXSID_GEN_DUMMY_DATA 1
* #define ENABLE_PGP_SIGNATURES 1
****/ ****/
#define DEBUG_IDS 1 #define DEBUG_IDS 1
#define DEBUG_RECOGN 1 #define DEBUG_RECOGN 1
#define ENABLE_PGP_SIGNATURES 1
#define ID_REQUEST_LIST 0x0001 #define ID_REQUEST_LIST 0x0001
@ -1984,9 +1982,7 @@ void p3IdService::CacheArbitrationDone(uint32_t mode)
//const int SHA_DIGEST_LENGTH = 20; //const int SHA_DIGEST_LENGTH = 20;
typedef Sha1CheckSum GxsIdPgpHash; static void calcPGPHash(const RsGxsId &id, const PGPFingerprintType &pgp, Sha1CheckSum &hash);
static void calcPGPHash(const RsGxsId &id, const PGPFingerprintType &pgp, GxsIdPgpHash &hash);
// Must Use meta. // Must Use meta.
@ -2078,7 +2074,7 @@ RsGenExchange::ServiceCreate_Return p3IdService::service_CreateGroup(RsGxsGrpIte
if (item->group.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID) if (item->group.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{ {
/* create the hash */ /* create the hash */
GxsIdPgpHash hash; Sha1CheckSum hash;
/* */ /* */
PGPFingerprintType ownFinger; PGPFingerprintType ownFinger;
@ -2094,8 +2090,6 @@ RsGenExchange::ServiceCreate_Return p3IdService::service_CreateGroup(RsGxsGrpIte
// } // }
#endif #endif
if (!AuthGPG::getAuthGPG()->getKeyFingerprint(ownId,ownFinger)) if (!AuthGPG::getAuthGPG()->getKeyFingerprint(ownId,ownFinger))
{ {
std::cerr << "p3IdService::service_CreateGroup() ERROR Own Finger is stuck"; std::cerr << "p3IdService::service_CreateGroup() ERROR Own Finger is stuck";
@ -2106,8 +2100,9 @@ RsGenExchange::ServiceCreate_Return p3IdService::service_CreateGroup(RsGxsGrpIte
std::cerr << "p3IdService::service_CreateGroup() OwnFingerprint: " << ownFinger.toStdString(); std::cerr << "p3IdService::service_CreateGroup() OwnFingerprint: " << ownFinger.toStdString();
std::cerr << std::endl; std::cerr << std::endl;
calcPGPHash(RsGxsId(item->group.mMeta.mGroupId.toStdString()), ownFinger, hash); RsGxsId gxsId(item->group.mMeta.mGroupId.toStdString());
item->group.mPgpIdHash = hash.toStdString(); calcPGPHash(gxsId, ownFinger, hash);
item->group.mPgpIdHash = hash;
#ifdef DEBUG_IDS #ifdef DEBUG_IDS
#endif // DEBUG_IDS #endif // DEBUG_IDS
@ -2118,7 +2113,6 @@ RsGenExchange::ServiceCreate_Return p3IdService::service_CreateGroup(RsGxsGrpIte
/* do signature */ /* do signature */
#ifdef ENABLE_PGP_SIGNATURES
#define MAX_SIGN_SIZE 2048 #define MAX_SIGN_SIZE 2048
uint8_t signarray[MAX_SIGN_SIZE]; uint8_t signarray[MAX_SIGN_SIZE];
unsigned int sign_size = MAX_SIGN_SIZE; unsigned int sign_size = MAX_SIGN_SIZE;
@ -2149,11 +2143,6 @@ RsGenExchange::ServiceCreate_Return p3IdService::service_CreateGroup(RsGxsGrpIte
std::cerr << std::endl; std::cerr << std::endl;
} }
/* done! */ /* done! */
#else
item->group.mPgpIdSign = "";
createStatus = SERVICE_CREATE_SUCCESS;
#endif
} }
else else
{ {
@ -2425,15 +2414,8 @@ bool p3IdService::checkId(const RsGxsIdGroup &grp, RsPgpId &pgpId)
std::cerr << std::endl; std::cerr << std::endl;
#endif // DEBUG_IDS #endif // DEBUG_IDS
if (grp.mPgpIdHash.length() != SHA_DIGEST_LENGTH * 2)
{
std::cerr << "ERROR PgpIdHash len:" << grp.mPgpIdHash.length();
std::cerr << std::endl;
}
/* iterate through and check hash */ /* iterate through and check hash */
GxsIdPgpHash ans(grp.mPgpIdHash); Sha1CheckSum ans = grp.mPgpIdHash;
#ifdef DEBUG_IDS #ifdef DEBUG_IDS
std::cerr << "\tExpected Answer: " << ans.toStdString(); std::cerr << "\tExpected Answer: " << ans.toStdString();
@ -2445,14 +2427,12 @@ bool p3IdService::checkId(const RsGxsIdGroup &grp, RsPgpId &pgpId)
std::map<RsPgpId, PGPFingerprintType>::iterator mit; std::map<RsPgpId, PGPFingerprintType>::iterator mit;
for(mit = mPgpFingerprintMap.begin(); mit != mPgpFingerprintMap.end(); mit++) for(mit = mPgpFingerprintMap.begin(); mit != mPgpFingerprintMap.end(); mit++)
{ {
GxsIdPgpHash hash; Sha1CheckSum hash;
calcPGPHash(RsGxsId(grp.mMeta.mGroupId.toStdString()), mit->second, hash); calcPGPHash(RsGxsId(grp.mMeta.mGroupId.toStdString()), mit->second, hash);
if (ans == hash) if (ans == hash)
{ {
std::cerr << "p3IdService::checkId() HASH MATCH!"; std::cerr << "p3IdService::checkId() HASH MATCH!";
std::cerr << std::endl; std::cerr << std::endl;
#ifdef ENABLE_PGP_SIGNATURES
std::cerr << "p3IdService::checkId() Hash : " << hash.toStdString(); std::cerr << "p3IdService::checkId() Hash : " << hash.toStdString();
std::cerr << std::endl; std::cerr << std::endl;
@ -2487,19 +2467,6 @@ bool p3IdService::checkId(const RsGxsIdGroup &grp, RsPgpId &pgpId)
} }
std::cerr << strout; std::cerr << strout;
std::cerr << std::endl; std::cerr << std::endl;
#else
pgpId = mit->first;
#ifdef DEBUG_IDS
std::cerr << "p3IdService::checkId() Skipping Signature check for now... Hash Okay";
std::cerr << std::endl;
#endif // DEBUG_IDS
return true;
#endif
} }
} }
@ -2549,7 +2516,7 @@ void p3IdService::getPgpIdList()
} }
void calcPGPHash(const RsGxsId &id, const PGPFingerprintType &pgp, GxsIdPgpHash &hash) void calcPGPHash(const RsGxsId &id, const PGPFingerprintType &pgp, Sha1CheckSum &hash)
{ {
unsigned char signature[SHA_DIGEST_LENGTH]; unsigned char signature[SHA_DIGEST_LENGTH];
/* hash id + pubkey => pgphash */ /* hash id + pubkey => pgphash */
@ -2559,7 +2526,7 @@ void calcPGPHash(const RsGxsId &id, const PGPFingerprintType &pgp, GxsIdPgpHash
SHA1_Update(sha_ctx, id.toStdString().c_str(), id.toStdString().length()); // TO FIX ONE DAY. SHA1_Update(sha_ctx, id.toStdString().c_str(), id.toStdString().length()); // TO FIX ONE DAY.
SHA1_Update(sha_ctx, pgp.toByteArray(), pgp.SIZE_IN_BYTES); SHA1_Update(sha_ctx, pgp.toByteArray(), pgp.SIZE_IN_BYTES);
SHA1_Final(signature, sha_ctx); SHA1_Final(signature, sha_ctx);
hash = GxsIdPgpHash(signature); hash = Sha1CheckSum(signature);
#ifdef DEBUG_IDS #ifdef DEBUG_IDS
std::cerr << "calcPGPHash():"; std::cerr << "calcPGPHash():";