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

merge of branch v0.6-idclean 7180

Browse source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@7187 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
chrisparker126 2014-03-17 20:56:06 +00:00
parent 7815efb16f
commit 0f29d28b1b
397 changed files with 6503 additions and 5702 deletions
Download patch file Download diff file Expand all files Collapse all files

214
libretroshare/src/gxs/rsdataservice.cc
View file

@ -278,17 +278,21 @@ RsGxsGrpMetaData* RsDataService::locked_getGrpMeta(RetroCursor &c)
uint32_t data_len = 0;
// grpId
c.getString(COL_GRP_ID, grpMeta->mGroupId);
// required definition of a group
ok &= !grpMeta->mGroupId.empty();
std::string tempId;
c.getString(COL_GRP_ID, tempId);
grpMeta->mGroupId = tempId;
c.getString(COL_IDENTITY, grpMeta->mAuthorId);
c.getString(COL_IDENTITY, tempId);
grpMeta->mAuthorId = tempId;
c.getString(COL_GRP_NAME, grpMeta->mGroupName);
c.getString(COL_ORIG_GRP_ID, grpMeta->mOrigGrpId);
c.getString(COL_ORIG_GRP_ID, tempId);
grpMeta->mOrigGrpId = tempId;
c.getString(COL_GRP_SERV_STRING, grpMeta->mServiceString);
c.getString(COL_HASH, grpMeta->mHash);
std::string temp;
c.getString(COL_HASH, temp);
grpMeta->mHash = temp;
grpMeta->mReputationCutOff = c.getInt32(COL_GRP_REP_CUTOFF);
grpMeta->mSignFlags = c.getInt32(COL_GRP_SIGN_FLAGS);
@ -311,15 +315,20 @@ RsGxsGrpMetaData* RsDataService::locked_getGrpMeta(RetroCursor &c)
grpMeta->mLastPost = c.getInt32(COL_GRP_LAST_POST);
grpMeta->mGroupStatus = c.getInt32(COL_GRP_STATUS);
c.getString(COL_GRP_CIRCLE_ID, grpMeta->mCircleId);
c.getString(COL_GRP_CIRCLE_ID, tempId);
grpMeta->mCircleId = tempId;
grpMeta->mCircleType = c.getInt32(COL_GRP_CIRCL_TYPE);
c.getString(COL_GRP_INTERN_CIRCLE, grpMeta->mInternalCircle);
c.getString(COL_GRP_ORIGINATOR, grpMeta->mOriginator);
c.getString(COL_GRP_INTERN_CIRCLE, tempId);
grpMeta->mInternalCircle = tempId;
std::string s ; c.getString(COL_GRP_ORIGINATOR, s) ;
grpMeta->mOriginator = RsPeerId(s);
grpMeta->mAuthenFlags = c.getInt32(COL_GRP_AUTHEN_FLAGS);
grpMeta->mRecvTS = c.getInt32(COL_GRP_RECV_TS);
c.getString(COL_PARENT_GRP_ID, grpMeta->mParentGrpId);
c.getString(COL_PARENT_GRP_ID, tempId);
grpMeta->mParentGrpId = tempId;
if(ok)
return grpMeta;
@ -344,8 +353,8 @@ RsNxsGrp* RsDataService::locked_getGroup(RetroCursor &c)
uint32_t data_len = 0;
// grpId
c.getString(COL_ACT_GROUP_ID, grp->grpId);
ok &= !grp->grpId.empty();
c.getStringT<RsGxsGroupId>(COL_ACT_GROUP_ID, grp->grpId);
ok &= !grp->grpId.isNull();
offset = 0; data_len = 0;
if(ok){
@ -394,17 +403,24 @@ RsGxsMsgMetaData* RsDataService::locked_getMsgMeta(RetroCursor &c)
char* data = NULL;
c.getString(COL_GRP_ID, msgMeta->mGroupId);
c.getString(COL_MSG_ID, msgMeta->mMsgId);
std::string gId;
c.getString(COL_GRP_ID, gId);
msgMeta->mGroupId = RsGxsGroupId(gId);
std::string temp;
c.getString(COL_MSG_ID, temp);
msgMeta->mMsgId = temp;
// without these, a msg is meaningless
ok &= (!msgMeta->mGroupId.empty()) && (!msgMeta->mMsgId.empty());
ok &= (!msgMeta->mGroupId.isNull()) && (!msgMeta->mMsgId.isNull());
c.getString(COL_ORIG_MSG_ID, msgMeta->mOrigMsgId);
c.getString(COL_IDENTITY, msgMeta->mAuthorId);
c.getString(COL_ORIG_MSG_ID, temp);
msgMeta->mOrigMsgId = temp;
c.getString(COL_IDENTITY, temp);
msgMeta->mAuthorId = temp;
c.getString(COL_MSG_NAME, msgMeta->mMsgName);
c.getString(COL_MSG_SERV_STRING, msgMeta->mServiceString);
c.getString(COL_HASH, msgMeta->mHash);
c.getString(COL_HASH, temp);
msgMeta->mHash = temp;
msgMeta->recvTS = c.getInt32(COL_MSG_RECV_TS);
offset = 0;
@ -418,8 +434,10 @@ RsGxsMsgMetaData* RsDataService::locked_getMsgMeta(RetroCursor &c)
offset = 0; data_len = 0;
// thread and parent id
c.getString(COL_THREAD_ID, msgMeta->mThreadId);
c.getString(COL_PARENT_ID, msgMeta->mParentId);
c.getString(COL_THREAD_ID, temp);
msgMeta->mThreadId = temp;
c.getString(COL_PARENT_ID, temp);
msgMeta->mParentId = temp;
// local meta
msgMeta->mMsgStatus = c.getInt32(COL_MSG_STATUS);
@ -444,10 +462,12 @@ RsNxsMsg* RsDataService::locked_getMessage(RetroCursor &c)
uint32_t data_len = 0,
offset = 0;
char* data = NULL;
c.getString(COL_ACT_GROUP_ID, msg->grpId);
c.getString(COL_ACT_MSG_ID, msg->msgId);
c.getStringT<RsGxsGroupId>(COL_ACT_GROUP_ID, msg->grpId);
std::string temp;
c.getString(COL_ACT_MSG_ID, temp);
msg->msgId = temp;
ok &= (!msg->grpId.empty()) && (!msg->msgId.empty());
ok &= (!msg->grpId.isNull()) && (!msg->msgId.isNull());
offset = 0; data_len = 0;
if(ok){
@ -504,7 +524,7 @@ int RsDataService::storeMessage(std::map<RsNxsMsg *, RsGxsMsgMetaData *> &msg)
if(!validSize(msgPtr)) continue;
// create or access file in binary
std::string msgFile = mServiceDir + "/" + msgPtr->grpId + "-msgs";
std::string msgFile = mServiceDir + "/" + msgPtr->grpId.toStdString() + "-msgs";
std::fstream ostrm(msgFile.c_str(), std::ios::binary | std::ios::app | std::ios::out);
ostrm.seekg(0, std::ios::end); // go to end to append
uint32_t offset = ostrm.tellg(); // get fill offset
@ -514,10 +534,10 @@ int RsDataService::storeMessage(std::map<RsNxsMsg *, RsGxsMsgMetaData *> &msg)
cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset);
cv.put(KEY_NXS_FILE, msgFile);
cv.put(KEY_NXS_FILE_LEN, (int32_t)msgPtr->msg.TlvSize());
cv.put(KEY_MSG_ID, msgMetaPtr->mMsgId);
cv.put(KEY_GRP_ID, msgMetaPtr->mGroupId);
cv.put(KEY_MSG_ID, msgMetaPtr->mMsgId.toStdString());
cv.put(KEY_GRP_ID, msgMetaPtr->mGroupId.toStdString());
cv.put(KEY_NXS_SERV_STRING, msgMetaPtr->mServiceString);
cv.put(KEY_NXS_HASH, msgMetaPtr->mHash);
cv.put(KEY_NXS_HASH, msgMetaPtr->mHash.toStdString());
cv.put(KEY_RECV_TS, (int32_t)msgMetaPtr->recvTS);
@ -525,7 +545,7 @@ int RsDataService::storeMessage(std::map<RsNxsMsg *, RsGxsMsgMetaData *> &msg)
offset = 0;
msgMetaPtr->signSet.SetTlv(signSetData, msgMetaPtr->signSet.TlvSize(), &offset);
cv.put(KEY_SIGN_SET, msgMetaPtr->signSet.TlvSize(), signSetData);
cv.put(KEY_NXS_IDENTITY, msgMetaPtr->mAuthorId);
cv.put(KEY_NXS_IDENTITY, msgMetaPtr->mAuthorId.toStdString());
cv.put(KEY_NXS_FLAGS, (int32_t) msgMetaPtr->mMsgFlags);
@ -536,9 +556,9 @@ int RsDataService::storeMessage(std::map<RsNxsMsg *, RsGxsMsgMetaData *> &msg)
msgPtr->meta.SetTlv(metaData, msgPtr->meta.TlvSize(), &offset);
cv.put(KEY_NXS_META, msgPtr->meta.TlvSize(), metaData);
cv.put(KEY_MSG_PARENT_ID, msgMetaPtr->mParentId);
cv.put(KEY_MSG_THREAD_ID, msgMetaPtr->mThreadId);
cv.put(KEY_ORIG_MSG_ID, msgMetaPtr->mOrigMsgId);
cv.put(KEY_MSG_PARENT_ID, msgMetaPtr->mParentId.toStdString());
cv.put(KEY_MSG_THREAD_ID, msgMetaPtr->mThreadId.toStdString());
cv.put(KEY_ORIG_MSG_ID, msgMetaPtr->mOrigMsgId.toStdString());
cv.put(KEY_MSG_NAME, msgMetaPtr->mMsgName);
// now local meta
@ -598,7 +618,7 @@ int RsDataService::storeGroup(std::map<RsNxsGrp *, RsGxsGrpMetaData *> &grp)
// if data is larger than max item size do not add
if(!validSize(grpPtr)) continue;
std::string grpFile = mServiceDir + "/" + grpPtr->grpId;
std::string grpFile = mServiceDir + "/" + grpPtr->grpId.toStdString();
std::fstream ostrm(grpFile.c_str(), std::ios::binary | std::ios::app | std::ios::out);
ostrm.seekg(0, std::ios::end); // go to end to append
uint32_t offset = ostrm.tellg(); // get fill offset
@ -613,25 +633,25 @@ int RsDataService::storeGroup(std::map<RsNxsGrp *, RsGxsGrpMetaData *> &grp)
cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset);
cv.put(KEY_NXS_FILE_LEN, (int32_t)grpPtr->grp.TlvSize());
cv.put(KEY_NXS_FILE, grpFile);
cv.put(KEY_GRP_ID, grpPtr->grpId);
cv.put(KEY_GRP_ID, grpPtr->grpId.toStdString());
cv.put(KEY_GRP_NAME, grpMetaPtr->mGroupName);
cv.put(KEY_ORIG_GRP_ID, grpMetaPtr->mOrigGrpId);
cv.put(KEY_ORIG_GRP_ID, grpMetaPtr->mOrigGrpId.toStdString());
cv.put(KEY_NXS_SERV_STRING, grpMetaPtr->mServiceString);
cv.put(KEY_NXS_FLAGS, (int32_t)grpMetaPtr->mGroupFlags);
cv.put(KEY_TIME_STAMP, (int32_t)grpMetaPtr->mPublishTs);
cv.put(KEY_GRP_SIGN_FLAGS, (int32_t)grpMetaPtr->mSignFlags);
cv.put(KEY_GRP_CIRCLE_ID, grpMetaPtr->mCircleId);
cv.put(KEY_GRP_CIRCLE_ID, grpMetaPtr->mCircleId.toStdString());
cv.put(KEY_GRP_CIRCLE_TYPE, (int32_t)grpMetaPtr->mCircleType);
cv.put(KEY_GRP_INTERNAL_CIRCLE, grpMetaPtr->mInternalCircle);
cv.put(KEY_GRP_ORIGINATOR, grpMetaPtr->mOriginator);
cv.put(KEY_GRP_INTERNAL_CIRCLE, grpMetaPtr->mInternalCircle.toStdString());
cv.put(KEY_GRP_ORIGINATOR, grpMetaPtr->mOriginator.toStdString());
cv.put(KEY_GRP_AUTHEN_FLAGS, (int32_t)grpMetaPtr->mAuthenFlags);
cv.put(KEY_PARENT_GRP_ID, grpMetaPtr->mParentGrpId);
cv.put(KEY_NXS_HASH, grpMetaPtr->mHash);
cv.put(KEY_PARENT_GRP_ID, grpMetaPtr->mParentGrpId.toStdString());
cv.put(KEY_NXS_HASH, grpMetaPtr->mHash.toStdString());
cv.put(KEY_RECV_TS, (int32_t)grpMetaPtr->mRecvTS);
cv.put(KEY_GRP_REP_CUTOFF, (int32_t)grpMetaPtr->mReputationCutOff);
if(! (grpMetaPtr->mAuthorId.empty()) ){
cv.put(KEY_NXS_IDENTITY, grpMetaPtr->mAuthorId);
if(! (grpMetaPtr->mAuthorId.isNull()) ){
cv.put(KEY_NXS_IDENTITY, grpMetaPtr->mAuthorId.toStdString());
}
offset = 0;
@ -693,7 +713,7 @@ int RsDataService::updateGroup(std::map<RsNxsGrp *, RsGxsGrpMetaData *> &grp)
// if data is larger than max item size do not add
if(!validSize(grpPtr)) continue;
std::string grpFile = mServiceDir + "/" + grpPtr->grpId;
std::string grpFile = mServiceDir + "/" + grpPtr->grpId.toStdString();
std::ofstream ostrm(grpFile.c_str(), std::ios::binary | std::ios::trunc);
uint32_t offset = 0; // get file offset
@ -707,22 +727,22 @@ int RsDataService::updateGroup(std::map<RsNxsGrp *, RsGxsGrpMetaData *> &grp)
cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset);
cv.put(KEY_NXS_FILE_LEN, (int32_t)grpPtr->grp.TlvSize());
cv.put(KEY_NXS_FILE, grpFile);
cv.put(KEY_GRP_ID, grpPtr->grpId);
cv.put(KEY_GRP_ID, grpPtr->grpId.toStdString());
cv.put(KEY_GRP_NAME, grpMetaPtr->mGroupName);
cv.put(KEY_ORIG_GRP_ID, grpMetaPtr->mOrigGrpId);
cv.put(KEY_ORIG_GRP_ID, grpMetaPtr->mOrigGrpId.toStdString());
cv.put(KEY_NXS_SERV_STRING, grpMetaPtr->mServiceString);
cv.put(KEY_NXS_FLAGS, (int32_t)grpMetaPtr->mGroupFlags);
cv.put(KEY_TIME_STAMP, (int32_t)grpMetaPtr->mPublishTs);
cv.put(KEY_GRP_SIGN_FLAGS, (int32_t)grpMetaPtr->mSignFlags);
cv.put(KEY_GRP_CIRCLE_ID, grpMetaPtr->mCircleId);
cv.put(KEY_GRP_CIRCLE_ID, grpMetaPtr->mCircleId.toStdString());
cv.put(KEY_GRP_CIRCLE_TYPE, (int32_t)grpMetaPtr->mCircleType);
cv.put(KEY_GRP_INTERNAL_CIRCLE, grpMetaPtr->mInternalCircle);
cv.put(KEY_GRP_ORIGINATOR, grpMetaPtr->mOriginator);
cv.put(KEY_GRP_INTERNAL_CIRCLE, grpMetaPtr->mInternalCircle.toStdString());
cv.put(KEY_GRP_ORIGINATOR, grpMetaPtr->mOriginator.toStdString());
cv.put(KEY_GRP_AUTHEN_FLAGS, (int32_t)grpMetaPtr->mAuthenFlags);
cv.put(KEY_NXS_HASH, grpMetaPtr->mHash);
cv.put(KEY_NXS_HASH, grpMetaPtr->mHash.toStdString());
if(! (grpMetaPtr->mAuthorId.empty()) ){
cv.put(KEY_NXS_IDENTITY, grpMetaPtr->mAuthorId);
if(! (grpMetaPtr->mAuthorId.isNull()) ){
cv.put(KEY_NXS_IDENTITY, grpMetaPtr->mAuthorId.toStdString());
}
offset = 0;
@ -748,7 +768,7 @@ int RsDataService::updateGroup(std::map<RsNxsGrp *, RsGxsGrpMetaData *> &grp)
ostrm.write(grpData, grpPtr->grp.TlvSize());
ostrm.close();
mDb->sqlUpdate(GRP_TABLE_NAME, "grpId='" + grpPtr->grpId + "'", cv);
mDb->sqlUpdate(GRP_TABLE_NAME, "grpId='" + grpPtr->grpId.toStdString() + "'", cv);
}
// finish transaction
bool ret = mDb->execSQL("COMMIT;");
@ -772,7 +792,7 @@ bool RsDataService::validSize(RsNxsGrp* grp) const
return false;
}
int RsDataService::retrieveNxsGrps(std::map<std::string, RsNxsGrp *> &grp, bool withMeta, bool cache){
int RsDataService::retrieveNxsGrps(std::map<RsGxsGroupId, RsNxsGrp *> &grp, bool withMeta, bool cache){
if(grp.empty()){
@ -797,14 +817,14 @@ int RsDataService::retrieveNxsGrps(std::map<std::string, RsNxsGrp *> &grp, bool
}else{
RsStackMutex stack(mDbMutex);
std::map<std::string, RsNxsGrp *>::iterator mit = grp.begin();
std::map<RsGxsGroupId, RsNxsGrp *>::iterator mit = grp.begin();
std::list<std::string> toRemove;
std::list<RsGxsGroupId> toRemove;
for(; mit != grp.end(); mit++)
{
const std::string& grpId = mit->first;
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpColumns, "grpId='" + grpId + "'", "");
const RsGxsGroupId& grpId = mit->first;
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpColumns, "grpId='" + grpId.toStdString() + "'", "");
if(c)
{
@ -823,7 +843,7 @@ int RsDataService::retrieveNxsGrps(std::map<std::string, RsNxsGrp *> &grp, bool
}
}
std::list<std::string>::iterator grpIdIt;
std::list<RsGxsGroupId>::iterator grpIdIt;
for (grpIdIt = toRemove.begin(); grpIdIt != toRemove.end(); ++grpIdIt)
{
grp.erase(*grpIdIt);
@ -833,7 +853,7 @@ int RsDataService::retrieveNxsGrps(std::map<std::string, RsNxsGrp *> &grp, bool
if(withMeta && !grp.empty())
{
std::map<RsGxsGroupId, RsGxsGrpMetaData*> metaMap;
std::map<std::string, RsNxsGrp *>::iterator mit = grp.begin();
std::map<RsGxsGroupId, RsNxsGrp *>::iterator mit = grp.begin();
for(; mit != grp.end(); mit++)
metaMap.insert(std::make_pair(mit->first, (RsGxsGrpMetaData*)(NULL)));
@ -878,17 +898,17 @@ int RsDataService::retrieveNxsMsgs(const GxsMsgReq &reqIds, GxsMsgResult &msg, b
for(; mit != reqIds.end(); mit++)
{
const std::string& grpId = mit->first;
const RsGxsGroupId& grpId = mit->first;
// if vector empty then request all messages
const std::vector<std::string>& msgIdV = mit->second;
const std::vector<RsGxsMessageId>& msgIdV = mit->second;
std::vector<RsNxsMsg*> msgSet;
if(msgIdV.empty()){
RsStackMutex stack(mDbMutex);
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId + "'", "");
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId.toStdString() + "'", "");
if(c)
locked_retrieveMessages(c, msgSet);
@ -897,15 +917,15 @@ int RsDataService::retrieveNxsMsgs(const GxsMsgReq &reqIds, GxsMsgResult &msg, b
}else{
// request each grp
std::vector<std::string>::const_iterator sit = msgIdV.begin();
std::vector<RsGxsMessageId>::const_iterator sit = msgIdV.begin();
for(; sit!=msgIdV.end();sit++){
const std::string& msgId = *sit;
const RsGxsMessageId& msgId = *sit;
RsStackMutex stack(mDbMutex);
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId
+ "' AND " + KEY_MSG_ID + "='" + msgId + "'", "");
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId.toStdString()
+ "' AND " + KEY_MSG_ID + "='" + msgId.toStdString() + "'", "");
if(c)
locked_retrieveMessages(c, msgSet);
@ -1012,26 +1032,26 @@ int RsDataService::retrieveGxsMsgMetaData(const GxsMsgReq& reqIds, GxsMsgMetaRes
for(; mit != reqIds.end(); mit++)
{
const std::string& grpId = mit->first;
const RsGxsGroupId& grpId = mit->first;
// if vector empty then request all messages
const std::vector<RsGxsMessageId>& msgIdV = mit->second;
std::vector<RsGxsMsgMetaData*> metaSet;
if(msgIdV.empty()){
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgMetaColumns, KEY_GRP_ID+ "='" + grpId + "'", "");
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgMetaColumns, KEY_GRP_ID+ "='" + grpId.toStdString() + "'", "");
locked_retrieveMsgMeta(c, metaSet);
}else{
// request each grp
std::vector<std::string>::const_iterator sit = msgIdV.begin();
std::vector<RsGxsMessageId>::const_iterator sit = msgIdV.begin();
for(; sit!=msgIdV.end();sit++){
const std::string& msgId = *sit;
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgMetaColumns, KEY_GRP_ID+ "='" + grpId
+ "' AND " + KEY_MSG_ID + "='" + msgId + "'", "");
const RsGxsMessageId& msgId = *sit;
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgMetaColumns, KEY_GRP_ID+ "='" + grpId.toStdString()
+ "' AND " + KEY_MSG_ID + "='" + msgId.toStdString() + "'", "");
locked_retrieveMsgMeta(c, metaSet);
}
@ -1094,7 +1114,7 @@ int RsDataService::retrieveGxsGrpMetaData(std::map<RsGxsGroupId, RsGxsGrpMetaDat
for(; mit != grp.end(); mit++)
{
const RsGxsGroupId& grpId = mit->first;
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpMetaColumns, "grpId='" + grpId + "'", "");
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpMetaColumns, "grpId='" + grpId.toStdString() + "'", "");
if(c)
{
@ -1128,10 +1148,10 @@ int RsDataService::resetDataStore()
std::cerr << "resetDataStore() " << std::endl;
#endif
std::map<std::string, RsNxsGrp*> grps;
std::map<RsGxsGroupId, RsNxsGrp*> grps;
retrieveNxsGrps(grps, false, false);
std::map<std::string, RsNxsGrp*>::iterator mit
std::map<RsGxsGroupId, RsNxsGrp*>::iterator mit
= grps.begin();
{
@ -1139,7 +1159,7 @@ int RsDataService::resetDataStore()
// remove all grp msgs files from service dir
for(; mit != grps.end(); mit++){
std::string file = mServiceDir + "/" + mit->first;
std::string file = mServiceDir + "/" + mit->first.toStdString();
std::string msgFile = file + "-msgs";
remove(file.c_str()); // remove group file
remove(msgFile.c_str()); // and remove messages file
@ -1161,7 +1181,7 @@ int RsDataService::updateGroupMetaData(GrpLocMetaData &meta)
{
RsStackMutex stack(mDbMutex);
RsGxsGroupId& grpId = meta.grpId;
return mDb->sqlUpdate(GRP_TABLE_NAME, KEY_GRP_ID+ "='" + grpId + "'", meta.val) ? 1 : 0;
return mDb->sqlUpdate(GRP_TABLE_NAME, KEY_GRP_ID+ "='" + grpId.toStdString() + "'", meta.val) ? 1 : 0;
}
int RsDataService::updateMessageMetaData(MsgLocMetaData &metaData)
@ -1169,8 +1189,8 @@ int RsDataService::updateMessageMetaData(MsgLocMetaData &metaData)
RsStackMutex stack(mDbMutex);
RsGxsGroupId& grpId = metaData.msgId.first;
RsGxsMessageId& msgId = metaData.msgId.second;
return mDb->sqlUpdate(MSG_TABLE_NAME, KEY_GRP_ID+ "='" + grpId
+ "' AND " + KEY_MSG_ID + "='" + msgId + "'", metaData.val) ? 1 : 0;
return mDb->sqlUpdate(MSG_TABLE_NAME, KEY_GRP_ID+ "='" + grpId.toStdString()
+ "' AND " + KEY_MSG_ID + "='" + msgId.toStdString() + "'", metaData.val) ? 1 : 0;
}
MsgOffset offSetAccum(const MsgOffset& x, const MsgOffset& y)
@ -1210,8 +1230,8 @@ int RsDataService::removeMsgs(const GxsMsgReq& msgIds)
std::vector<MsgOffset> msgOffsets;
locked_getMessageOffsets(grpId, msgOffsets);
std::string oldFileName = mServiceDir + "/" + grpId + "-msgs";
std::string newFileName = mServiceDir + "/" + grpId + "-msgs-temp";
std::string oldFileName = mServiceDir + "/" + grpId.toStdString() + "-msgs";
std::string newFileName = mServiceDir + "/" + grpId.toStdString() + "-msgs-temp";
std::ifstream in(oldFileName.c_str(), std::ios::binary);
std::vector<char> dataBuff, newBuffer;
@ -1281,7 +1301,7 @@ int RsDataService::removeMsgs(const GxsMsgReq& msgIds)
return 1;
}
int RsDataService::removeGroups(const std::vector<std::string> &grpIds)
int RsDataService::removeGroups(const std::vector<RsGxsGroupId> &grpIds)
{
RsStackMutex stack(mDbMutex);
@ -1290,10 +1310,10 @@ int RsDataService::removeGroups(const std::vector<std::string> &grpIds)
// first remove file then remove group
// from db
std::vector<std::string>::const_iterator vit = grpIds.begin();
std::vector<RsGxsGroupId>::const_iterator vit = grpIds.begin();
for(; vit != grpIds.end(); vit++)
{
const std::string grpFileName = mServiceDir + "/" + *vit;
const std::string grpFileName = mServiceDir + "/" + (*vit).toStdString();
remove(grpFileName.c_str());
}
@ -1302,7 +1322,7 @@ int RsDataService::removeGroups(const std::vector<std::string> &grpIds)
return 1;
}
int RsDataService::retrieveGroupIds(std::vector<std::string> &grpIds)
int RsDataService::retrieveGroupIds(std::vector<RsGxsGroupId> &grpIds)
{
RsStackMutex stack(mDbMutex);
@ -1316,7 +1336,7 @@ int RsDataService::retrieveGroupIds(std::vector<std::string> &grpIds)
{
std::string grpId;
c->getString(0, grpId);
grpIds.push_back(grpId);
grpIds.push_back(RsGxsGroupId(grpId));
valid = c->moveToNext();
}
delete c;
@ -1345,8 +1365,8 @@ bool RsDataService::locked_updateMessageEntries(const MsgUpdates& updates)
for(; vit != updateV.end(); vit++)
{
const MsgUpdate& update = *vit;
mDb->sqlUpdate(MSG_TABLE_NAME, KEY_GRP_ID+ "='" + grpId
+ "' AND " + KEY_MSG_ID + "='" + update.msgId + "'", update.cv);
mDb->sqlUpdate(MSG_TABLE_NAME, KEY_GRP_ID+ "='" + grpId.toStdString()
+ "' AND " + KEY_MSG_ID + "='" + update.msgId.toStdString() + "'", update.cv);
}
}
@ -1371,8 +1391,8 @@ bool RsDataService::locked_removeMessageEntries(const GxsMsgReq& msgIds)
for(; vit != msgsV.end(); vit++)
{
const RsGxsMessageId& msgId = *vit;
mDb->sqlDelete(MSG_TABLE_NAME, KEY_GRP_ID+ "='" + grpId
+ "' AND " + KEY_MSG_ID + "='" + msgId + "'", "");
mDb->sqlDelete(MSG_TABLE_NAME, KEY_GRP_ID+ "='" + grpId.toStdString()
+ "' AND " + KEY_MSG_ID + "='" + msgId.toStdString() + "'", "");
}
}
@ -1381,18 +1401,18 @@ bool RsDataService::locked_removeMessageEntries(const GxsMsgReq& msgIds)
return ret;
}
bool RsDataService::locked_removeGroupEntries(const std::vector<std::string>& grpIds)
bool RsDataService::locked_removeGroupEntries(const std::vector<RsGxsGroupId>& grpIds)
{
// start a transaction
bool ret = mDb->execSQL("BEGIN;");
std::vector<std::string>::const_iterator vit = grpIds.begin();
std::vector<RsGxsGroupId>::const_iterator vit = grpIds.begin();
for(; vit != grpIds.end(); vit++)
{
const RsGxsGroupId& grpId = *vit;
mDb->sqlDelete(GRP_TABLE_NAME, KEY_GRP_ID+ "='" + grpId + "'", "");
mDb->sqlDelete(GRP_TABLE_NAME, KEY_GRP_ID+ "='" + grpId.toStdString() + "'", "");
}
ret &= mDb->execSQL("COMMIT;");
@ -1402,7 +1422,7 @@ bool RsDataService::locked_removeGroupEntries(const std::vector<std::string>& gr
void RsDataService::locked_getMessageOffsets(const RsGxsGroupId& grpId, std::vector<MsgOffset>& offsets)
{
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, mMsgOffSetColumns, KEY_GRP_ID+ "='" + grpId + "'", "");
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, mMsgOffSetColumns, KEY_GRP_ID+ "='" + grpId.toStdString() + "'", "");
if(c)
{
@ -1413,7 +1433,9 @@ void RsDataService::locked_getMessageOffsets(const RsGxsGroupId& grpId, std::vec
RsGxsMessageId msgId;
int32_t msgLen;
int32_t msgOffSet;
c->getString(0, msgId);
std::string temp;
c->getString(0, temp);
msgId = temp;
msgOffSet = c->getInt32(1);
msgLen = c->getInt32(2);

6
libretroshare/src/gxs/rsdataservice.h
View file

@ -73,7 +73,7 @@ public:
* @param cache whether to store retrieval in mem for faster later retrieval
* @return error code
*/
int retrieveNxsGrps(std::map<std::string, RsNxsGrp*>& grp, bool withMeta, bool cache);
int retrieveNxsGrps(std::map<RsGxsGroupId, RsNxsGrp*>& grp, bool withMeta, bool cache);
/*!
* Retrieves meta data of all groups stored (most current versions only)
@ -111,7 +111,7 @@ public:
* @param grpIds all grpids in store is inserted into this vector
* @return error code
*/
int retrieveGroupIds(std::vector<std::string> &grpIds);
int retrieveGroupIds(std::vector<RsGxsGroupId> &grpIds);
/*!
* @return the cache size set for this RsGeneralDataService in bytes
@ -226,7 +226,7 @@ private:
* @param msgIds
*/
bool locked_removeMessageEntries(const GxsMsgReq& msgIds);
bool locked_removeGroupEntries(const std::vector<std::string>& grpIds);
bool locked_removeGroupEntries(const std::vector<RsGxsGroupId>& grpIds);
typedef std::map<RsGxsGroupId, std::vector<MsgUpdate> > MsgUpdates;

44
libretroshare/src/gxs/rsgenexchange.cc
View file

@ -421,7 +421,7 @@ int RsGenExchange::createGroupSignatures(RsTlvKeySignatureSet& signSet, RsTlvBin
PrivacyBitPos pos = GRP_OPTION_BITS;
// Check required permissions, and allow them to sign it - if they want too - as well!
if ((!grpMeta.mAuthorId.empty()) || checkAuthenFlag(pos, author_flag))
if ((!grpMeta.mAuthorId.isNull()) || checkAuthenFlag(pos, author_flag))
{
needIdentitySign = true;
std::cerr << "Needs Identity sign! (Service Flags)";
@ -502,7 +502,7 @@ int RsGenExchange::createMsgSignatures(RsTlvKeySignatureSet& signSet, RsTlvBinar
uint8_t author_flag = GXS_SERV::MSG_AUTHEN_ROOT_AUTHOR_SIGN;
uint8_t publish_flag = GXS_SERV::MSG_AUTHEN_ROOT_PUBLISH_SIGN;
if(!msgMeta.mParentId.empty())
if(!msgMeta.mParentId.isNull())
{
// Child Message.
author_flag = GXS_SERV::MSG_AUTHEN_CHILD_AUTHOR_SIGN;
@ -536,7 +536,7 @@ int RsGenExchange::createMsgSignatures(RsTlvKeySignatureSet& signSet, RsTlvBinar
std::cerr << std::endl;
}
if (!msgMeta.mAuthorId.empty())
if (!msgMeta.mAuthorId.isNull())
{
needIdentitySign = true;
std::cerr << "Needs Identity sign! (AuthorId Exists)";
@ -690,7 +690,9 @@ int RsGenExchange::createMessage(RsNxsMsg* msg)
// get hash of msg data to create msg id
pqihash hash;
hash.addData(allMsgData, allMsgDataLen);
hash.Complete(msg->msgId);
RsFileHash hashId;
hash.Complete(hashId);
msg->msgId = hashId;
// assign msg id to msg meta
msg->metaData->mMsgId = msg->msgId;
@ -723,7 +725,7 @@ int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, RsTlvSecu
uint8_t author_flag = GXS_SERV::MSG_AUTHEN_ROOT_AUTHOR_SIGN;
uint8_t publish_flag = GXS_SERV::MSG_AUTHEN_ROOT_PUBLISH_SIGN;
if(!msg->metaData->mParentId.empty())
if(!msg->metaData->mParentId.isNull())
{
// Child Message.
author_flag = GXS_SERV::MSG_AUTHEN_CHILD_AUTHOR_SIGN;
@ -744,7 +746,7 @@ int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, RsTlvSecu
needPublishSign = true;
// Check required permissions, if they have signed it anyway - we need to validate it.
if ((checkAuthenFlag(pos, author_flag)) || (!msg->metaData->mAuthorId.empty()))
if ((checkAuthenFlag(pos, author_flag)) || (!msg->metaData->mAuthorId.isNull()))
needIdentitySign = true;
@ -814,7 +816,7 @@ int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, RsTlvSecu
}else
{
std::list<std::string> peers;
std::list<RsPeerId> peers;
peers.push_back(msg->PeerId());
mGixs->requestKey(metaData.mAuthorId, peers);
return VALIDATE_FAIL_TRY_LATER;
@ -853,7 +855,7 @@ int RsGenExchange::validateGrp(RsNxsGrp* grp, RsTlvSecurityKeySet& grpKeySet)
PrivacyBitPos pos = GRP_OPTION_BITS;
// Check required permissions, and allow them to sign it - if they want too - as well!
if (!(metaData.mAuthorId.empty()) || checkAuthenFlag(pos, author_flag))
if (!(metaData.mAuthorId.isNull()) || checkAuthenFlag(pos, author_flag))
{
needIdentitySign = true;
std::cerr << "Needs Identity sign! (Service Flags)";
@ -888,7 +890,7 @@ int RsGenExchange::validateGrp(RsNxsGrp* grp, RsTlvSecurityKeySet& grpKeySet)
}else
{
std::list<std::string> peers;
std::list<RsPeerId> peers;
peers.push_back(grp->PeerId());
mGixs->requestKey(metaData.mAuthorId, peers);
return VALIDATE_FAIL_TRY_LATER;
@ -1769,7 +1771,7 @@ void RsGenExchange::publishMsgs()
{
// empty orig msg id means this is the original
// msg
if(msg->metaData->mOrigMsgId.empty())
if(msg->metaData->mOrigMsgId.isNull())
{
msg->metaData->mOrigMsgId = msg->metaData->mMsgId;
}
@ -1858,7 +1860,7 @@ void RsGenExchange::processGroupUpdatePublish()
// get keys for group update publish
// first build meta request map for groups to be updated
std::map<std::string, RsGxsGrpMetaData*> grpMeta;
std::map<RsGxsGroupId, RsGxsGrpMetaData*> grpMeta;
std::vector<GroupUpdatePublish>::iterator vit = mGroupUpdatePublish.begin();
for(; vit != mGroupUpdatePublish.end(); vit++)
@ -1879,7 +1881,7 @@ void RsGenExchange::processGroupUpdatePublish()
{
GroupUpdatePublish& gup = *vit;
const RsGxsGroupId& groupId = gup.grpItem->meta.mGroupId;
std::map<std::string, RsGxsGrpMetaData*>::iterator mit = grpMeta.find(groupId);
std::map<RsGxsGroupId, RsGxsGrpMetaData*>::iterator mit = grpMeta.find(groupId);
RsGxsGrpMetaData* meta = NULL;
if(mit == grpMeta.end())
@ -1966,7 +1968,7 @@ void RsGenExchange::publishGrps()
{
// timed out
toNotify.insert(std::make_pair(
token, GrpNote(false, "")));
token, GrpNote(false, RsGxsGroupId())));
delete ggps.mItem;
vit = mGrpsToPublish.erase(vit);
@ -2013,7 +2015,7 @@ void RsGenExchange::publishGrps()
if(privKeyFound)
{
// get group id from private admin key id
grpItem->meta.mGroupId = grp->grpId = privAdminKey.keyId;
grpItem->meta.mGroupId = grp->grpId = RsGxsGroupId(privAdminKey.keyId);
ServiceCreate_Return ret = service_CreateGroup(grpItem, privatekeySet);
@ -2174,7 +2176,7 @@ RsGeneralDataService* RsGenExchange::getDataStore()
bool RsGenExchange::getGroupKeys(const RsGxsGroupId &grpId, RsTlvSecurityKeySet &keySet)
{
if(grpId.empty())
if(grpId.isNull())
return false;
RsStackMutex stack(mGenMtx);
@ -2205,7 +2207,7 @@ void RsGenExchange::processRecvdData()
}
void RsGenExchange::computeHash(const RsTlvBinaryData& data, std::string& hash)
void RsGenExchange::computeHash(const RsTlvBinaryData& data, RsFileHash& hash)
{
pqihash pHash;
pHash.addData(data.bin_data, data.bin_len);
@ -2364,8 +2366,8 @@ void RsGenExchange::processRecvdGroups()
return;
NxsGrpPendValidVect::iterator vit = mReceivedGrps.begin();
std::vector<std::string> existingGrpIds;
std::list<std::string> grpIds;
std::vector<RsGxsGroupId> existingGrpIds;
std::list<RsGxsGroupId> grpIds;
std::map<RsNxsGrp*, RsGxsGrpMetaData*> grps;
@ -2476,7 +2478,7 @@ void RsGenExchange::performUpdateValidation()
if(mGroupUpdates.empty())
return;
std::map<std::string, RsGxsGrpMetaData*> grpMetas;
std::map<RsGxsGroupId, RsGxsGrpMetaData*> grpMetas;
std::vector<GroupUpdate>::iterator vit = mGroupUpdates.begin();
for(; vit != mGroupUpdates.end(); vit++)
@ -2491,7 +2493,7 @@ void RsGenExchange::performUpdateValidation()
for(; vit != mGroupUpdates.end(); vit++)
{
GroupUpdate& gu = *vit;
std::map<std::string, RsGxsGrpMetaData*>::iterator mit =
std::map<RsGxsGroupId, RsGxsGrpMetaData*>::iterator mit =
grpMetas.find(gu.newGrp->grpId);
gu.oldGrpMeta = mit->second;
gu.validUpdate = updateValid(*(gu.oldGrpMeta), *(gu.newGrp));
@ -2544,7 +2546,7 @@ bool RsGenExchange::updateValid(RsGxsGrpMetaData& oldGrpMeta, RsNxsGrp& newGrp)
RsTlvKeySignature adminSign = mit->second;
std::map<std::string, RsTlvSecurityKey>& keys = oldGrpMeta.keys.keys;
std::map<std::string, RsTlvSecurityKey>::iterator keyMit = keys.find(oldGrpMeta.mGroupId);
std::map<std::string, RsTlvSecurityKey>::iterator keyMit = keys.find(oldGrpMeta.mGroupId.toStdString());
if(keyMit == keys.end())
{

2
libretroshare/src/gxs/rsgenexchange.h
View file

@ -763,7 +763,7 @@ private:
void groupShareKeys(std::list<std::string> peers);
static void computeHash(const RsTlvBinaryData& data, std::string& hash);
static void computeHash(const RsTlvBinaryData& data, RsFileHash& hash);
/*!
* Checks validation of recently received groups to be

9
libretroshare/src/gxs/rsgixs.h
View file

@ -32,7 +32,7 @@
#include "retroshare/rsgxscircles.h"
#include "serialiser/rstlvkeys.h"
#include "retroshare/rsids.h"
/*!
* GIXP: General Identity Exchange Service.
*
@ -96,9 +96,8 @@
* as these will be used very frequently.
*****/
typedef std::string PeerId; // SHOULD BE REMOVED => RsPeerId (SSLID)
typedef std::string RsPgpId;
typedef std::string RsGxsId;
typedef RsPeerId PeerId; // SHOULD BE REMOVED => RsPeerId (SSLID)
typedef PGPIdType RsPgpId;
//
//// External Interface -
@ -176,7 +175,7 @@ class RsGixsReputation
public:
// get Reputation.
virtual bool haveReputation(const RsGxsId &id) = 0;
virtual bool loadReputation(const RsGxsId &id, const std::list<std::string>& peers) = 0;
virtual bool loadReputation(const RsGxsId &id, const std::list<RsPeerId>& peers) = 0;
virtual bool getReputation(const RsGxsId &id, GixsReputation &rep) = 0;
};

4
libretroshare/src/gxs/rsgroups.h
View file

@ -74,8 +74,8 @@
#pragma once
typedef std::string SSLId ;
typedef std::string GPGId ;
typedef RsPeerId SSLId ;
typedef RsPgpId GPGId ;
typedef uint64_t RsGroupId ;
class RsPeerGroupInfo

66
libretroshare/src/gxs/rsgxsdata.cc
View file

@ -37,19 +37,19 @@ uint32_t RsGxsGrpMetaData::serial_size()
{
uint32_t s = 8; // header size
s += GetTlvStringSize(mGroupId);
s += GetTlvStringSize(mOrigGrpId);
s += mGroupId.serial_size();
s += mOrigGrpId.serial_size();
s += GetTlvStringSize(mGroupName);
s += 4;
s += 4;
s += GetTlvStringSize(mAuthorId);
s += mAuthorId.serial_size();
s += GetTlvStringSize(mServiceString);
s += signSet.TlvSize();
s += keys.TlvSize();
s += 4; // for mCircleType
s += GetTlvStringSize(mCircleId);
s += mCircleId.serial_size();
s += 4; // mAuthenFlag
s += GetTlvStringSize(mParentGrpId);
s += mParentGrpId.serial_size();
return s;
}
@ -105,17 +105,17 @@ bool RsGxsGrpMetaData::serialise(void *data, uint32_t &pktsize)
/* skip header */
offset += 8;
ok &= SetTlvString(data, tlvsize, &offset, 0, mGroupId);
ok &= SetTlvString(data, tlvsize, &offset, 0, mOrigGrpId);
ok &= SetTlvString(data, tlvsize, &offset, 0, mParentGrpId);
ok &= mGroupId.serialise(data, tlvsize, offset);
ok &= mOrigGrpId.serialise(data, tlvsize, offset);
ok &= mParentGrpId.serialise(data, tlvsize, offset);
ok &= SetTlvString(data, tlvsize, &offset, 0, mGroupName);
ok &= setRawUInt32(data, tlvsize, &offset, mGroupFlags);
ok &= setRawUInt32(data, tlvsize, &offset, mPublishTs);
ok &= setRawUInt32(data, tlvsize, &offset, mCircleType);
ok &= setRawUInt32(data, tlvsize, &offset, mAuthenFlags);
ok &= SetTlvString(data, tlvsize, &offset, 0, mAuthorId);
ok &= mAuthorId.serialise(data, tlvsize, offset);
ok &= SetTlvString(data, tlvsize, &offset, 0, mServiceString);
ok &= SetTlvString(data, tlvsize, &offset, 0, mCircleId);
ok &= mCircleId.serialise(data, tlvsize, offset);
ok &= signSet.SetTlv(data, tlvsize, &offset);
ok &= keys.SetTlv(data, tlvsize, &offset);
@ -136,17 +136,17 @@ bool RsGxsGrpMetaData::deserialise(void *data, uint32_t &pktsize)
if(!ok) return false;
ok &= GetTlvString(data, pktsize, &offset, 0, mGroupId);
ok &= GetTlvString(data, pktsize, &offset, 0, mOrigGrpId);
ok &= GetTlvString(data, pktsize, &offset, 0, mParentGrpId);
ok &= mGroupId.deserialise(data, pktsize, offset);
ok &= mOrigGrpId.deserialise(data, pktsize, offset);
ok &= mParentGrpId.deserialise(data, pktsize, offset);
ok &= GetTlvString(data, pktsize, &offset, 0, mGroupName);
ok &= getRawUInt32(data, pktsize, &offset, &mGroupFlags);
ok &= getRawUInt32(data, pktsize, &offset, &mPublishTs);
ok &= getRawUInt32(data, pktsize, &offset, &mCircleType);
ok &= getRawUInt32(data, pktsize, &offset, &mAuthenFlags);
ok &= GetTlvString(data, pktsize, &offset, 0, mAuthorId);
ok &= mAuthorId.deserialise(data, pktsize, offset);
ok &= GetTlvString(data, pktsize, &offset, 0, mServiceString);
ok &= GetTlvString(data, pktsize, &offset, 0, mCircleId);
ok &= mCircleId.deserialise(data, pktsize, offset);
ok &= signSet.GetTlv(data, pktsize, &offset);
ok &= keys.GetTlv(data, pktsize, &offset);
@ -171,12 +171,12 @@ uint32_t RsGxsMsgMetaData::serial_size()
uint32_t s = 8; // header size
s += GetTlvStringSize(mGroupId);
s += GetTlvStringSize(mMsgId);
s += GetTlvStringSize(mThreadId);
s += GetTlvStringSize(mParentId);
s += GetTlvStringSize(mOrigMsgId);
s += GetTlvStringSize(mAuthorId);
s += mGroupId.serial_size();
s += mMsgId.serial_size();
s += mThreadId.serial_size();
s += mParentId.serial_size();
s += mOrigMsgId.serial_size();
s += mAuthorId.serial_size();
s += signSet.TlvSize();
s += GetTlvStringSize(mMsgName);
@ -228,12 +228,12 @@ bool RsGxsMsgMetaData::serialise(void *data, uint32_t *size)
/* skip header */
offset += 8;
ok &= SetTlvString(data, *size, &offset, 0, mGroupId);
ok &= SetTlvString(data, *size, &offset, 0, mMsgId);
ok &= SetTlvString(data, *size, &offset, 0, mThreadId);
ok &= SetTlvString(data, *size, &offset, 0, mParentId);
ok &= SetTlvString(data, *size, &offset, 0, mOrigMsgId);
ok &= SetTlvString(data, *size, &offset, 0, mAuthorId);
ok &= mGroupId.serialise(data, *size, offset);
ok &= mMsgId.serialise(data, *size, offset);
ok &= mThreadId.serialise(data, *size, offset);
ok &= mParentId.serialise(data, *size, offset);
ok &= mOrigMsgId.serialise(data, *size, offset);
ok &= mAuthorId.serialise(data, *size, offset);
ok &= signSet.SetTlv(data, *size, &offset);
ok &= SetTlvString(data, *size, &offset, 0, mMsgName);
@ -255,12 +255,12 @@ bool RsGxsMsgMetaData::deserialise(void *data, uint32_t *size)
if(!ok) return false;
ok &= GetTlvString(data, *size, &offset, 0, mGroupId);
ok &= GetTlvString(data, *size, &offset, 0, mMsgId);
ok &= GetTlvString(data, *size, &offset, 0, mThreadId);
ok &= GetTlvString(data, *size, &offset, 0, mParentId);
ok &= GetTlvString(data, *size, &offset, 0, mOrigMsgId);
ok &= GetTlvString(data, *size, &offset, 0, mAuthorId);
ok &= mGroupId.deserialise(data, *size, offset);
ok &= mMsgId.deserialise(data, *size, offset);
ok &= mThreadId.deserialise(data, *size, offset);
ok &= mParentId.deserialise(data, *size, offset);
ok &= mOrigMsgId.deserialise(data, *size, offset);
ok &= mAuthorId.deserialise(data, *size, offset);
ok &= signSet.GetTlv(data, *size, &offset);
ok &= GetTlvString(data, *size, &offset, 0, mMsgName);

14
libretroshare/src/gxs/rsgxsdata.h
View file

@ -52,9 +52,9 @@ public:
uint32_t mGroupFlags;
uint32_t mPublishTs;
uint32_t mSignFlags;
std::string mAuthorId;
RsGxsId mAuthorId;
std::string mCircleId;
RsGxsCircleId mCircleId;
uint32_t mCircleType;
@ -76,9 +76,9 @@ public:
uint32_t mGroupStatus;
uint32_t mRecvTS;
std::string mOriginator;
std::string mInternalCircle;
std::string mHash;
RsPeerId mOriginator;
RsGxsCircleId mInternalCircle;
RsFileHash mHash;
};
@ -100,7 +100,7 @@ public:
RsGxsMessageId mThreadId;
RsGxsMessageId mParentId;
RsGxsMessageId mOrigMsgId;
std::string mAuthorId;
RsGxsId mAuthorId;
RsTlvKeySignatureSet signSet;
@ -116,7 +116,7 @@ public:
uint32_t mMsgStatus;
time_t mChildTs;
uint32_t recvTS;
std::string mHash;
RsFileHash mHash;
bool validated;
};

16
libretroshare/src/gxs/rsgxsdataaccess.cc
View file

@ -65,7 +65,7 @@ RsGxsDataAccess::RsGxsDataAccess(RsGeneralDataService* ds)
bool RsGxsDataAccess::requestGroupInfo(uint32_t &token, uint32_t ansType, const RsTokReqOptions &opts,
const std::list<std::string> &groupIds)
const std::list<RsGxsGroupId> &groupIds)
{
if(groupIds.empty())
{
@ -854,7 +854,7 @@ bool RsGxsDataAccess::getGroupList(const std::list<RsGxsGroupId>& grpIdsIn, cons
mDataStore->retrieveGxsGrpMetaData(grpMeta);
std::map<std::string, RsGxsGrpMetaData*>::iterator mit = grpMeta.begin();
std::map<RsGxsGroupId, RsGxsGrpMetaData*>::iterator mit = grpMeta.begin();
for(; mit != grpMeta.end(); mit++)
{
@ -958,8 +958,8 @@ bool RsGxsDataAccess::getMsgList(const GxsMsgReq& msgIds, const RsTokReqOptions&
std::vector<RsGxsMsgMetaData*>::const_iterator vit = metaV.begin();
// RUN THROUGH ALL MSGS... in map origId -> TS.
std::map<RsGxsGroupId, std::pair<RsGxsMessageId, time_t> > origMsgTs;
std::map<RsGxsGroupId, std::pair<RsGxsMessageId, time_t> >::iterator oit;
std::map<RsGxsMessageId, std::pair<RsGxsMessageId, time_t> > origMsgTs;
std::map<RsGxsMessageId, std::pair<RsGxsMessageId, time_t> >::iterator oit;
for(; vit != metaV.end(); vit++)
{
@ -968,7 +968,7 @@ bool RsGxsDataAccess::getMsgList(const GxsMsgReq& msgIds, const RsTokReqOptions&
/* if we are grabbing thread Head... then parentId == empty. */
if (onlyThreadHeadMsgs)
{
if (!(msgMeta->mParentId.empty()))
if (!(msgMeta->mParentId.isNull()))
{
continue;
}
@ -1025,7 +1025,7 @@ bool RsGxsDataAccess::getMsgList(const GxsMsgReq& msgIds, const RsTokReqOptions&
/* if we are grabbing thread Head... then parentId == empty. */
if (onlyThreadHeadMsgs)
{
if (!(msgMeta->mParentId.empty()))
if (!(msgMeta->mParentId.isNull()))
{
continue;
}
@ -1209,8 +1209,8 @@ bool RsGxsDataAccess::getMsgRelatedInfo(MsgRelatedInfoReq *req)
if (onlyChildMsgs || onlyThreadMsgs)
{
// RUN THROUGH ALL MSGS... in map origId -> TS.
std::map<std::string, std::pair<std::string, time_t> > origMsgTs;
std::map<std::string, std::pair<std::string, time_t> >::iterator oit;
std::map<RsGxsMessageId, std::pair<RsGxsMessageId, time_t> > origMsgTs;
std::map<RsGxsMessageId, std::pair<RsGxsMessageId, time_t> >::iterator oit;
for(vit_meta = metaV.begin(); vit_meta != metaV.end(); vit_meta++)
{

2
libretroshare/src/gxs/rsgxsdataaccess.h
View file

@ -164,7 +164,7 @@ public:
* @param msgIds
* @return false if token cannot be redeemed, if false you may have tried to redeem when not ready
*/
bool getGroupList(const uint32_t &token, std::list<std::string> &groupIds);
bool getGroupList(const uint32_t &token, std::list<RsGxsGroupId> &groupIds);
/*!
*

104
libretroshare/src/gxs/rsgxsnetservice.cc
View file

@ -80,10 +80,10 @@ int RsGxsNetService::tick(){
void RsGxsNetService::syncWithPeers()
{
std::set<std::string> peers;
std::set<RsPeerId> peers;
mNetMgr->getOnlineList(peers);
std::set<std::string>::iterator sit = peers.begin();
std::set<RsPeerId>::iterator sit = peers.begin();
if(mGrpAutoSync)
{
@ -91,7 +91,7 @@ void RsGxsNetService::syncWithPeers()
for(; sit != peers.end(); sit++)
{
const std::string peerId = *sit;
const RsPeerId peerId = *sit;
ClientGrpMap::const_iterator cit = mClientGrpUpdateMap.find(peerId);
uint32_t updateTS = 0;
@ -108,7 +108,7 @@ void RsGxsNetService::syncWithPeers()
}
}
#ifdef GXS_ENABLE_SYNC_MSGS
#ifndef GXS_DISABLE_SYNC_MSGS
std::map<RsGxsGroupId, RsGxsGrpMetaData* > grpMeta;
mDataStore->retrieveGxsGrpMetaData(grpMeta);
@ -154,7 +154,7 @@ void RsGxsNetService::syncWithPeers()
uint32_t updateTS = 0;
if(mui)
{
std::map<std::string, uint32_t>::const_iterator cit2 = mui->msgUpdateTS.find(*vit);
std::map<RsGxsGroupId, uint32_t>::const_iterator cit2 = mui->msgUpdateTS.find(*vit);
if(cit2 != mui->msgUpdateTS.end())
{
@ -432,7 +432,7 @@ void RsGxsNetService::locked_createTransactionFromPending(MsgCircleIdsRequestVet
}
bool RsGxsNetService::locked_canReceive(const RsGxsGrpMetaData * const grpMeta,
const std::string& peerId)
const RsPeerId& peerId)
{
double timeDelta = 0.2;
@ -518,7 +518,7 @@ void RsGxsNetService::collateGrpFragments(GrpFragments fragments,
struct MsgFragCollate
{
RsGxsGroupId mMsgId;
RsGxsMessageId mMsgId;
MsgFragCollate(const RsGxsMessageId& msgId) : mMsgId(msgId){ }
bool operator()(RsNxsMsg* msg) { return msg->msgId == mMsgId;}
};
@ -725,7 +725,7 @@ bool RsGxsNetService::handleTransaction(RsNxsItem* item)
RsStackMutex stack(mNxsMutex);
const std::string& peer = item->PeerId();
const RsPeerId& peer = item->PeerId();
RsNxsTransac* transItem = dynamic_cast<RsNxsTransac*>(item);
@ -788,7 +788,7 @@ bool RsGxsNetService::locked_processTransac(RsNxsTransac* item)
* For ending a transaction the
*/
std::string peer;
RsPeerId peer;
// for outgoing transaction use own id
if(item->transactFlag & (RsNxsTransac::FLAG_BEGIN_P2 | RsNxsTransac::FLAG_END_SUCCESS))
@ -1233,7 +1233,7 @@ void RsGxsNetService::locked_processCompletedIncomingTrans(NxsTransaction* tr)
mObserver->notifyNewGroups(grps);
// now note this as the latest you've received from this peer
std::string peerFrom = tr->mTransaction->PeerId();
RsPeerId peerFrom = tr->mTransaction->PeerId();
uint32_t updateTS = tr->mTransaction->updateTS;
ClientGrpMap::iterator it = mClientGrpUpdateMap.find(peerFrom);
@ -1261,13 +1261,13 @@ void RsGxsNetService::locked_processCompletedIncomingTrans(NxsTransaction* tr)
std::vector<RsNxsMsg*> msgs;
std::string grpId;
RsGxsGroupId grpId;
while(tr->mItems.size() > 0)
{
RsNxsMsg* msg = dynamic_cast<RsNxsMsg*>(tr->mItems.front());
if(msg)
{
if(grpId.empty())
if(grpId.isNull())
grpId = msg->grpId;
tr->mItems.pop_front();
@ -1312,11 +1312,11 @@ void RsGxsNetService::locked_processCompletedIncomingTrans(NxsTransaction* tr)
return;
}
void RsGxsNetService::locked_doMsgUpdateWork(const RsNxsTransac *nxsTrans, const std::string &grpId)
void RsGxsNetService::locked_doMsgUpdateWork(const RsNxsTransac *nxsTrans, const RsGxsGroupId &grpId)
{
// firts check if peer exists
const std::string& peerFrom = nxsTrans->PeerId();
const RsPeerId& peerFrom = nxsTrans->PeerId();
ClientMsgMap::iterator it = mClientMsgUpdateMap.find(peerFrom);
@ -1406,7 +1406,7 @@ void RsGxsNetService::locked_processCompletedOutgoingTrans(NxsTransaction* tr)
void RsGxsNetService::locked_pushMsgTransactionFromList(
std::list<RsNxsItem*>& reqList, const std::string& peerId, const uint32_t& transN)
std::list<RsNxsItem*>& reqList, const RsPeerId& peerId, const uint32_t& transN)
{
RsNxsTransac* transac = new RsNxsTransac(mServType);
transac->transactFlag = RsNxsTransac::FLAG_TYPE_MSG_LIST_REQ
@ -1462,7 +1462,7 @@ void RsGxsNetService::locked_genReqMsgTransaction(NxsTransaction* tr)
// get grp id for this transaction
RsNxsSyncMsgItem* item = msgItemL.front();
const std::string& grpId = item->grpId;
const RsGxsGroupId& grpId = item->grpId;
std::map<std::string, RsGxsGrpMetaData*> grpMetaMap;
grpMetaMap[grpId] = NULL;
@ -1499,7 +1499,7 @@ void RsGxsNetService::locked_genReqMsgTransaction(NxsTransaction* tr)
std::vector<RsGxsMsgMetaData*> &msgMetaV = result[grpId];
std::vector<RsGxsMsgMetaData*>::const_iterator vit = msgMetaV.begin();
std::set<std::string> msgIdSet;
std::set<RsGxsMessageId> msgIdSet;
// put ids in set for each searching
for(; vit != msgMetaV.end(); vit++)
@ -1516,17 +1516,17 @@ void RsGxsNetService::locked_genReqMsgTransaction(NxsTransaction* tr)
std::list<RsNxsSyncMsgItem*>::iterator llit = msgItemL.begin();
std::list<RsNxsItem*> reqList;
const std::string peerFrom = tr->mTransaction->PeerId();
const RsPeerId peerFrom = tr->mTransaction->PeerId();
MsgAuthorV toVet;
std::list<std::string> peers;
std::list<RsPeerId> peers;
peers.push_back(tr->mTransaction->PeerId());
for(; llit != msgItemL.end(); llit++)
{
RsNxsSyncMsgItem*& syncItem = *llit;
const std::string& msgId = syncItem->msgId;
const RsGxsMessageId& msgId = syncItem->msgId;
if(msgIdSet.find(msgId) == msgIdSet.end()){
@ -1534,7 +1534,7 @@ void RsGxsNetService::locked_genReqMsgTransaction(NxsTransaction* tr)
// or if there isn't an author (note as author requirement is
// enforced at service level, if no author is needed then reputation
// filtering is optional)
bool noAuthor = syncItem->authorId.empty();
bool noAuthor = syncItem->authorId.isNull();
// grp meta must be present if author present
if(!noAuthor && grpMeta == NULL)
@ -1586,7 +1586,7 @@ void RsGxsNetService::locked_genReqMsgTransaction(NxsTransaction* tr)
}
void RsGxsNetService::locked_pushGrpTransactionFromList(
std::list<RsNxsItem*>& reqList, const std::string& peerId, const uint32_t& transN)
std::list<RsNxsItem*>& reqList, const RsPeerId& peerId, const uint32_t& transN)
{
RsNxsTransac* transac = new RsNxsTransac(mServType);
transac->transactFlag = RsNxsTransac::FLAG_TYPE_GRP_LIST_REQ
@ -1606,7 +1606,7 @@ void RsGxsNetService::locked_pushGrpTransactionFromList(
delete newTrans;
}
void RsGxsNetService::addGroupItemToList(NxsTransaction*& tr,
const std::string& grpId, uint32_t& transN,
const RsGxsGroupId& grpId, uint32_t& transN,
std::list<RsNxsItem*>& reqList)
{
RsNxsSyncGrpItem* grpItem = new RsNxsSyncGrpItem(mServType);
@ -1643,8 +1643,8 @@ void RsGxsNetService::locked_genReqGrpTransaction(NxsTransaction* tr)
}
}
std::map<std::string, RsGxsGrpMetaData*> grpMetaMap;
std::map<std::string, RsGxsGrpMetaData*>::const_iterator metaIter;
std::map<RsGxsGroupId, RsGxsGrpMetaData*> grpMetaMap;
std::map<RsGxsGroupId, RsGxsGrpMetaData*>::const_iterator metaIter;
mDataStore->retrieveGxsGrpMetaData(grpMetaMap);
// now do compare and add loop
@ -1654,13 +1654,13 @@ void RsGxsNetService::locked_genReqGrpTransaction(NxsTransaction* tr)
uint32_t transN = locked_getTransactionId();
GrpAuthorV toVet;
std::list<std::string> peers;
std::list<RsPeerId> peers;
peers.push_back(tr->mTransaction->PeerId());
for(; llit != grpItemL.end(); llit++)
{
RsNxsSyncGrpItem*& grpSyncItem = *llit;
const std::string& grpId = grpSyncItem->grpId;
const RsGxsGroupId& grpId = grpSyncItem->grpId;
metaIter = grpMetaMap.find(grpId);
bool haveItem = false;
bool latestVersion = false;
@ -1673,7 +1673,7 @@ void RsGxsNetService::locked_genReqGrpTransaction(NxsTransaction* tr)
if(!haveItem || (haveItem && latestVersion) ){
// determine if you need to check reputation
bool checkRep = !grpSyncItem->authorId.empty();
bool checkRep = !grpSyncItem->authorId.isNull();
// check if you have reputation, if you don't then
// place in holding pen
@ -1708,7 +1708,7 @@ void RsGxsNetService::locked_genReqGrpTransaction(NxsTransaction* tr)
if(!toVet.empty())
{
std::string peerId = tr->mTransaction->PeerId();
RsPeerId peerId = tr->mTransaction->PeerId();
GrpRespPending* grp = new GrpRespPending(mReputations, peerId, toVet);
mPendingResp.push_back(grp);
}
@ -1721,7 +1721,7 @@ void RsGxsNetService::locked_genReqGrpTransaction(NxsTransaction* tr)
}
// clean up meta data
std::map<std::string, RsGxsGrpMetaData*>::iterator mit = grpMetaMap.begin();
std::map<RsGxsGroupId, RsGxsGrpMetaData*>::iterator mit = grpMetaMap.begin();
for(; mit != grpMetaMap.end(); mit++)
delete mit->second;
@ -1740,7 +1740,7 @@ void RsGxsNetService::locked_genSendGrpsTransaction(NxsTransaction* tr)
std::list<RsNxsItem*>::iterator lit = tr->mItems.begin();
std::map<std::string, RsNxsGrp*> grps;
std::map<RsGxsGroupId, RsNxsGrp*> grps;
for(;lit != tr->mItems.end(); lit++)
{
@ -1771,8 +1771,8 @@ void RsGxsNetService::locked_genSendGrpsTransaction(NxsTransaction* tr)
uint32_t transN = locked_getTransactionId();
// store grp items to send in transaction
std::map<std::string, RsNxsGrp*>::iterator mit = grps.begin();
std::string peerId = tr->mTransaction->PeerId();
std::map<RsGxsGroupId, RsNxsGrp*>::iterator mit = grps.begin();
RsPeerId peerId = tr->mTransaction->PeerId();
for(;mit != grps.end(); mit++)
{
mit->second->PeerId(peerId); // set so it gets sent to right peer
@ -1909,7 +1909,7 @@ void RsGxsNetService::locked_genSendMsgsTransaction(NxsTransaction* tr)
return;
}
std::string grpId = "";
RsGxsGroupId grpId;
for(;lit != tr->mItems.end(); lit++)
{
@ -1918,7 +1918,7 @@ void RsGxsNetService::locked_genSendMsgsTransaction(NxsTransaction* tr)
{
msgIds[item->grpId].push_back(item->msgId);
if(grpId.empty())
if(grpId.isNull())
grpId = item->grpId;
}
else
@ -1939,7 +1939,7 @@ void RsGxsNetService::locked_genSendMsgsTransaction(NxsTransaction* tr)
// store msg items to send in transaction
GxsMsgResult::iterator mit = msgs.begin();
std::string peerId = tr->mTransaction->PeerId();
RsPeerId peerId = tr->mTransaction->PeerId();
uint32_t msgSize = 0;
for(;mit != msgs.end(); mit++)
@ -2008,7 +2008,7 @@ uint32_t RsGxsNetService::locked_getTransactionId()
}
bool RsGxsNetService::locked_addTransaction(NxsTransaction* tr)
{
const std::string& peer = tr->mTransaction->PeerId();
const RsPeerId& peer = tr->mTransaction->PeerId();
uint32_t transN = tr->mTransaction->transactionNumber;
TransactionIdMap& transMap = mTransactions[peer];
bool transNumExist = transMap.find(transN)
@ -2041,7 +2041,7 @@ void RsGxsNetService::cleanTransactionItems(NxsTransaction* tr) const
}
void RsGxsNetService::locked_pushGrpRespFromList(std::list<RsNxsItem*>& respList,
const std::string& peer, const uint32_t& transN)
const RsPeerId& peer, const uint32_t& transN)
{
NxsTransaction* tr = new NxsTransaction();
tr->mItems = respList;
@ -2085,17 +2085,17 @@ void RsGxsNetService::handleRecvSyncGroup(RsNxsSyncGrp* item)
if(!locked_CanReceiveUpdate(item))
return;
std::string peer = item->PeerId();
RsPeerId peer = item->PeerId();
std::map<std::string, RsGxsGrpMetaData*> grp;
std::map<RsGxsGroupId, RsGxsGrpMetaData*> grp;
mDataStore->retrieveGxsGrpMetaData(grp);
if(grp.empty())
return;
std::map<std::string, RsGxsGrpMetaData*>::iterator mit =
std::map<RsGxsGroupId, RsGxsGrpMetaData*>::iterator mit =
grp.begin();
std::list<RsNxsItem*> itemL;
@ -2151,7 +2151,7 @@ void RsGxsNetService::handleRecvSyncGroup(RsNxsSyncGrp* item)
bool RsGxsNetService::canSendGrpId(const std::string& sslId, RsGxsGrpMetaData& grpMeta, std::vector<GrpIdCircleVet>& toVet)
bool RsGxsNetService::canSendGrpId(const RsPeerId& sslId, RsGxsGrpMetaData& grpMeta, std::vector<GrpIdCircleVet>& toVet)
{
// first do the simple checks
uint8_t circleType = grpMeta.mCircleType;
@ -2180,7 +2180,7 @@ bool RsGxsNetService::canSendGrpId(const std::string& sslId, RsGxsGrpMetaData& g
{
// a non empty internal circle id means this
// is the personal circle owner
if(!grpMeta.mInternalCircle.empty())
if(!grpMeta.mInternalCircle.isNull())
{
const RsGxsCircleId& internalCircleId = grpMeta.mCircleId;
if(mCircles->isLoaded(internalCircleId))
@ -2231,12 +2231,12 @@ void RsGxsNetService::handleRecvSyncMessage(RsNxsSyncMsg* item)
if(!locked_CanReceiveUpdate(item))
return;
const std::string& peer = item->PeerId();
const RsPeerId& peer = item->PeerId();
GxsMsgMetaResult metaResult;
GxsMsgReq req;
std::map<std::string, RsGxsGrpMetaData*> grpMetas;
std::map<RsGxsGroupId, RsGxsGrpMetaData*> grpMetas;
grpMetas[item->grpId] = NULL;
mDataStore->retrieveGxsGrpMetaData(grpMetas);
RsGxsGrpMetaData* grpMeta = grpMetas[item->grpId];
@ -2244,7 +2244,7 @@ void RsGxsNetService::handleRecvSyncMessage(RsNxsSyncMsg* item)
if(grpMeta == NULL)
return;
req[item->grpId] = std::vector<std::string>();
req[item->grpId] = std::vector<RsGxsMessageId>();
mDataStore->retrieveGxsMsgMetaData(req, metaResult);
std::vector<RsGxsMsgMetaData*>& msgMetas = metaResult[item->grpId];
@ -2289,7 +2289,7 @@ void RsGxsNetService::handleRecvSyncMessage(RsNxsSyncMsg* item)
delete(grpMeta);
}
void RsGxsNetService::locked_pushMsgRespFromList(std::list<RsNxsItem*>& itemL, const std::string& sslId,
void RsGxsNetService::locked_pushMsgRespFromList(std::list<RsNxsItem*>& itemL, const RsPeerId& sslId,
const uint32_t& transN)
{
NxsTransaction* tr = new NxsTransaction();
@ -2317,7 +2317,7 @@ void RsGxsNetService::locked_pushMsgRespFromList(std::list<RsNxsItem*>& itemL, c
}
bool RsGxsNetService::canSendMsgIds(const std::vector<RsGxsMsgMetaData*>& msgMetas,
const RsGxsGrpMetaData& grpMeta, const std::string& sslId)
const RsGxsGrpMetaData& grpMeta, const RsPeerId& sslId)
{
// first do the simple checks
uint8_t circleType = grpMeta.mCircleType;
@ -2360,7 +2360,7 @@ bool RsGxsNetService::canSendMsgIds(const std::vector<RsGxsMsgMetaData*>& msgMet
{
// a non empty internal circle id means this
// is the personal circle owner
if(!grpMeta.mInternalCircle.empty())
if(!grpMeta.mInternalCircle.isNull())
{
const RsGxsCircleId& internalCircleId = grpMeta.mCircleId;
if(mCircles->isLoaded(internalCircleId))
@ -2412,7 +2412,7 @@ void RsGxsNetService::setSyncAge(uint32_t age)
}
int RsGxsNetService::requestGrp(const std::list<RsGxsGroupId>& grpId, const std::string& peerId)
int RsGxsNetService::requestGrp(const std::list<RsGxsGroupId>& grpId, const RsPeerId& peerId)
{
RsStackMutex stack(mNxsMutex);
mExplicitRequest[peerId].assign(grpId.begin(), grpId.end());
@ -2423,11 +2423,11 @@ void RsGxsNetService::processExplicitGroupRequests()
{
RsStackMutex stack(mNxsMutex);
std::map<std::string, std::list<RsGxsGroupId> >::const_iterator cit = mExplicitRequest.begin();
std::map<RsPeerId, std::list<RsGxsGroupId> >::const_iterator cit = mExplicitRequest.begin();
for(; cit != mExplicitRequest.end(); cit++)
{
const std::string& peerId = cit->first;
const RsPeerId& peerId = cit->first;
const std::list<RsGxsGroupId>& groupIdList = cit->second;
std::list<RsNxsItem*> grpSyncItems;

36
libretroshare/src/gxs/rsgxsnetservice.h
View file

@ -43,7 +43,7 @@
typedef std::map<uint32_t, NxsTransaction*> TransactionIdMap;
/// to keep track of peers active transactions
typedef std::map<std::string, TransactionIdMap > TransactionsPeerMap;
typedef std::map<RsPeerId, TransactionIdMap > TransactionsPeerMap;
/*!
@ -92,7 +92,7 @@ public:
* Circumvents polling of peers for message
* @param peerId id of peer
*/
void requestGroupsOfPeer(const std::string& peerId){ return;}
void requestGroupsOfPeer(const RsPeerId& peerId){ return;}
/*!
* get messages of a peer for a given group id, this circumvents the normal
@ -100,7 +100,7 @@ public:
* @param peerId Id of peer
* @param grpId id of group to request messages for
*/
void requestMessagesOfPeer(const std::string& peerId, const std::string& grpId){ return; }
void requestMessagesOfPeer(const RsPeerId& peerId, const std::string& grpId){ return; }
/*!
* pauses synchronisation of subscribed groups and request for group id
@ -124,7 +124,7 @@ public:
* @param enabled set to false to disable pause, and true otherwise
* @return request token to be redeemed
*/
int requestGrp(const std::list<RsGxsGroupId>& grpId, const std::string& peerId);
int requestGrp(const std::list<RsGxsGroupId>& grpId, const RsPeerId& peerId);
/* p3Config methods */
@ -302,30 +302,30 @@ private:
* @param toVet groupid/peer to vet are stored here if their circle id is not cached
* @return false, if you cannot send to this peer, true otherwise
*/
bool canSendGrpId(const std::string& sslId, RsGxsGrpMetaData& grpMeta, std::vector<GrpIdCircleVet>& toVet);
bool canSendGrpId(const RsPeerId& sslId, RsGxsGrpMetaData& grpMeta, std::vector<GrpIdCircleVet>& toVet);
bool canSendMsgIds(const std::vector<RsGxsMsgMetaData*>& msgMetas, const RsGxsGrpMetaData&, const std::string& sslId);
bool canSendMsgIds(const std::vector<RsGxsMsgMetaData*>& msgMetas, const RsGxsGrpMetaData&, const RsPeerId& sslId);
void locked_createTransactionFromPending(MsgRespPending* grpPend);
void locked_createTransactionFromPending(GrpRespPending* msgPend);
void locked_createTransactionFromPending(GrpCircleIdRequestVetting* grpPend);
void locked_createTransactionFromPending(MsgCircleIdsRequestVetting* grpPend);
void locked_pushMsgTransactionFromList(std::list<RsNxsItem*>& reqList, const std::string& peerId, const uint32_t& transN);
void locked_pushGrpTransactionFromList(std::list<RsNxsItem*>& reqList, const std::string& peerId, const uint32_t& transN);
void locked_pushGrpRespFromList(std::list<RsNxsItem*>& respList, const std::string& peer, const uint32_t& transN);
void locked_pushMsgRespFromList(std::list<RsNxsItem*>& itemL, const std::string& sslId, const uint32_t& transN);
void locked_pushMsgTransactionFromList(std::list<RsNxsItem*>& reqList, const RsPeerId& peerId, const uint32_t& transN);
void locked_pushGrpTransactionFromList(std::list<RsNxsItem*>& reqList, const RsPeerId& peerId, const uint32_t& transN);
void locked_pushGrpRespFromList(std::list<RsNxsItem*>& respList, const RsPeerId& peer, const uint32_t& transN);
void locked_pushMsgRespFromList(std::list<RsNxsItem*>& itemL, const RsPeerId& sslId, const uint32_t& transN);
void syncWithPeers();
void addGroupItemToList(NxsTransaction*& tr,
const std::string& grpId, uint32_t& transN,
const RsGxsGroupId& grpId, uint32_t& transN,
std::list<RsNxsItem*>& reqList);
bool locked_canReceive(const RsGxsGrpMetaData * const grpMeta, const std::string& peerId);
bool locked_canReceive(const RsGxsGrpMetaData * const grpMeta, const RsPeerId& peerId);
void processExplicitGroupRequests();
void locked_doMsgUpdateWork(const RsNxsTransac* nxsTrans, const std::string& grpId);
void locked_doMsgUpdateWork(const RsNxsTransac* nxsTrans, const RsGxsGroupId& grpId);
void updateServerSyncTS();
@ -415,7 +415,7 @@ private:
uint32_t mTransactionTimeOut;
std::string mOwnId;
RsPeerId mOwnId;
RsNxsNetMgr* mNetMgr;
@ -434,16 +434,16 @@ private:
std::vector<AuthorPending*> mPendingResp;
std::vector<GrpCircleVetting*> mPendingCircleVets;
std::map<std::string, std::list<RsGxsGroupId> > mExplicitRequest;
std::map<RsPeerId, std::list<RsGxsGroupId> > mExplicitRequest;
// nxs sync optimisation
// can pull dynamically the latest timestamp for each message
public:
typedef std::map<std::string, RsGxsMsgUpdateItem*> ClientMsgMap;
typedef std::map<std::string, RsGxsServerMsgUpdateItem*> ServerMsgMap;
typedef std::map<std::string, RsGxsGrpUpdateItem*> ClientGrpMap;
typedef std::map<RsPeerId, RsGxsMsgUpdateItem*> ClientMsgMap;
typedef std::map<RsGxsGroupId, RsGxsServerMsgUpdateItem*> ServerMsgMap;
typedef std::map<RsPeerId, RsGxsGrpUpdateItem*> ClientGrpMap;
private:

24
libretroshare/src/gxs/rsgxsnetutils.cc
View file

@ -47,14 +47,14 @@ bool AuthorPending::expired() const
}
bool AuthorPending::getAuthorRep(GixsReputation& rep,
const std::string& authorId, const std::string& peerId)
const RsGxsId& authorId, const RsPeerId& peerId)
{
if(mRep->haveReputation(authorId))
{
return mRep->getReputation(authorId, rep);
}
std::list<std::string> peers;
std::list<RsPeerId> peers;
peers.push_back(peerId);
mRep->loadReputation(authorId, peers);
return false;
@ -70,12 +70,12 @@ GrpAuthEntry::GrpAuthEntry()
MsgRespPending::MsgRespPending(RsGixsReputation* rep, const std::string& peerId, const MsgAuthorV& msgAuthV, int cutOff)
MsgRespPending::MsgRespPending(RsGixsReputation* rep, const RsPeerId& peerId, const MsgAuthorV& msgAuthV, int cutOff)
: AuthorPending(rep, time(NULL)), mPeerId(peerId), mMsgAuthV(msgAuthV), mCutOff(cutOff)
{
}
GrpRespPending::GrpRespPending(RsGixsReputation* rep, const std::string& peerId, const GrpAuthorV& grpAuthV, int cutOff)
GrpRespPending::GrpRespPending(RsGixsReputation* rep, const RsPeerId& peerId, const GrpAuthorV& grpAuthV, int cutOff)
: AuthorPending(rep, time(NULL)), mPeerId(peerId), mGrpAuthV(grpAuthV), mCutOff(cutOff)
{
}
@ -192,23 +192,23 @@ RsNxsNetMgrImpl::RsNxsNetMgrImpl(p3LinkMgr *lMgr)
}
std::string RsNxsNetMgrImpl::getOwnId()
const RsPeerId& RsNxsNetMgrImpl::getOwnId()
{
RsStackMutex stack(mNxsNetMgrMtx);
return mLinkMgr->getOwnId();
}
void RsNxsNetMgrImpl::getOnlineList(std::set<std::string> &ssl_peers)
void RsNxsNetMgrImpl::getOnlineList(std::set<RsPeerId> &ssl_peers)
{
ssl_peers.clear();
std::list<std::string> pList;
std::list<RsPeerId> pList;
{
RsStackMutex stack(mNxsNetMgrMtx);
mLinkMgr->getOnlineList(pList);
}
std::list<std::string>::const_iterator lit = pList.begin();
std::list<RsPeerId>::const_iterator lit = pList.begin();
for(; lit != pList.end(); lit++)
ssl_peers.insert(*lit);
@ -233,7 +233,7 @@ bool GrpCircleVetting::expired()
{
return time(NULL) > (mTimeStamp + EXPIRY_PERIOD_OFFSET);
}
bool GrpCircleVetting::canSend(const RsPgpId& peerId, const RsGxsCircleId& circleId)
bool GrpCircleVetting::canSend(const SSLIdType& peerId, const RsGxsCircleId& circleId)
{
if(mCircles->isLoaded(circleId))
{
@ -247,7 +247,7 @@ bool GrpCircleVetting::canSend(const RsPgpId& peerId, const RsGxsCircleId& circl
}
GrpCircleIdRequestVetting::GrpCircleIdRequestVetting(
RsGcxs* const circles, std::vector<GrpIdCircleVet> grpCircleV, const std::string& peerId)
RsGcxs* const circles, std::vector<GrpIdCircleVet> grpCircleV, const RsPeerId& peerId)
: GrpCircleVetting(circles), mGrpCircleV(grpCircleV), mPeerId(peerId) {}
bool GrpCircleIdRequestVetting::cleared()
@ -281,13 +281,13 @@ int GrpCircleIdRequestVetting::getType() const
}
MsgIdCircleVet::MsgIdCircleVet(const RsGxsMessageId& msgId,
const std::string& authorId)
const RsGxsId& authorId)
: mMsgId(msgId), mAuthorId(authorId) {
}
MsgCircleIdsRequestVetting::MsgCircleIdsRequestVetting(RsGcxs* const circles,
std::vector<MsgIdCircleVet> msgs, const RsGxsGroupId& grpId,
const std::string& peerId, const RsGxsCircleId& circleId)
const RsPeerId& peerId, const RsGxsCircleId& circleId)
: GrpCircleVetting(circles), mMsgs(msgs), mGrpId(grpId), mPeerId(peerId), mCircleId(circleId) {}
bool MsgCircleIdsRequestVetting::cleared()

36
libretroshare/src/gxs/rsgxsnetutils.h
View file

@ -81,8 +81,8 @@ class RsNxsNetMgr
public:
virtual ~RsNxsNetMgr(){};
virtual std::string getOwnId() = 0;
virtual void getOnlineList(std::set<std::string>& ssl_peers) = 0;
virtual const RsPeerId& getOwnId() = 0;
virtual void getOnlineList(std::set<RsPeerId>& ssl_peers) = 0;
};
@ -94,8 +94,8 @@ public:
RsNxsNetMgrImpl(p3LinkMgr* lMgr);
virtual ~RsNxsNetMgrImpl(){};
std::string getOwnId();
void getOnlineList(std::set<std::string>& ssl_peers);
const RsPeerId& getOwnId();
void getOnlineList(std::set<RsPeerId>& ssl_peers);
private:
@ -141,7 +141,7 @@ protected:
* @param authorId reputation to get
* @return true if successfully retrieve repution
*/
bool getAuthorRep(GixsReputation& rep, const std::string& authorId, const std::string& peerId);
bool getAuthorRep(GixsReputation& rep, const RsGxsId& authorId, const RsPeerId& peerId);
private:
@ -158,7 +158,7 @@ public:
RsGxsMessageId mMsgId;
RsGxsGroupId mGrpId;
std::string mAuthorId;
RsGxsId mAuthorId;
bool mPassedVetting;
};
@ -171,7 +171,7 @@ public:
GrpAuthEntry();
RsGxsGroupId mGrpId;
std::string mAuthorId;
RsGxsId mAuthorId;
bool mPassedVetting;
};
@ -182,11 +182,11 @@ class MsgRespPending : public AuthorPending
{
public:
MsgRespPending(RsGixsReputation* rep, const std::string& peerId, const MsgAuthorV& msgAuthV, int cutOff = 0);
MsgRespPending(RsGixsReputation* rep, const RsPeerId& peerId, const MsgAuthorV& msgAuthV, int cutOff = 0);
int getType() const;
bool accepted();
std::string mPeerId;
RsPeerId mPeerId;
MsgAuthorV mMsgAuthV;
int mCutOff;
};
@ -195,10 +195,10 @@ class GrpRespPending : public AuthorPending
{
public:
GrpRespPending(RsGixsReputation* rep, const std::string& peerId, const GrpAuthorV& grpAuthV, int cutOff = 0);
GrpRespPending(RsGixsReputation* rep, const RsPeerId& peerId, const GrpAuthorV& grpAuthV, int cutOff = 0);
int getType() const;
bool accepted();
std::string mPeerId;
RsPeerId mPeerId;
GrpAuthorV mGrpAuthV;
int mCutOff;
};
@ -218,10 +218,10 @@ public:
class MsgIdCircleVet
{
public:
MsgIdCircleVet(const RsGxsMessageId& grpId, const std::string& authorId);
MsgIdCircleVet(const RsGxsMessageId& grpId, const RsGxsId& authorId);
RsGxsMessageId mMsgId;
std::string mAuthorId;
RsGxsId mAuthorId;
};
class GrpItemCircleVet
@ -250,7 +250,7 @@ public:
virtual bool cleared() = 0;
protected:
bool canSend(const RsPgpId& peerId, const RsGxsCircleId& circleId);
bool canSend(const RsPeerId& peerId, const RsGxsCircleId& circleId);
private:
@ -261,23 +261,23 @@ private:
class GrpCircleIdRequestVetting : public GrpCircleVetting
{
public:
GrpCircleIdRequestVetting(RsGcxs* const circles, std::vector<GrpIdCircleVet> mGrpCircleV, const std::string& peerId);
GrpCircleIdRequestVetting(RsGcxs* const circles, std::vector<GrpIdCircleVet> mGrpCircleV, const RsPeerId& peerId);
bool cleared();
int getType() const;
std::vector<GrpIdCircleVet> mGrpCircleV;
std::string mPeerId;
RsPeerId mPeerId;
};
class MsgCircleIdsRequestVetting : public GrpCircleVetting
{
public:
MsgCircleIdsRequestVetting(RsGcxs* const circles, std::vector<MsgIdCircleVet> msgs, const RsGxsGroupId& grpId,
const std::string& peerId, const RsGxsCircleId& circleId);
const RsPeerId& peerId, const RsGxsCircleId& circleId);
bool cleared();
int getType() const;
std::vector<MsgIdCircleVet> mMsgs;
RsGxsGroupId mGrpId;
std::string mPeerId;
RsPeerId mPeerId;
RsGxsCircleId mCircleId;
};

6
libretroshare/src/gxs/rsgxsrequesttypes.h
View file

@ -50,7 +50,7 @@ class GroupMetaReq : public GxsRequest
{
public:
std::list<std::string> mGroupIds;
std::list<RsGxsGroupId> mGroupIds;
std::list<RsGxsGrpMetaData*> mGroupMetaData;
};
@ -59,8 +59,8 @@ class GroupIdReq : public GxsRequest
public:
std::list<std::string> mGroupIds;
std::list<std::string> mGroupIdResult;
std::list<RsGxsGroupId> mGroupIds;
std::list<RsGxsGroupId> mGroupIdResult;
};
class GroupDataReq : public GxsRequest

4
libretroshare/src/gxs/rsgxsutil.cc
View file

@ -130,7 +130,7 @@ bool RsGxsIntegrityCheck::check()
for(; git != grp.end(); git++)
{
RsNxsGrp* grp = git->second;
std::string currHash;
RsFileHash currHash;
pqihash pHash;
pHash.addData(grp->grp.bin_data, grp->grp.bin_len);
pHash.Complete(currHash);
@ -157,7 +157,7 @@ bool RsGxsIntegrityCheck::check()
for(; vit != msgV.end(); vit++)
{
RsNxsMsg* msg = *vit;
std::string currHash;
RsFileHash currHash;
pqihash pHash;
pHash.addData(msg->msg.bin_data, msg->msg.bin_len);
pHash.Complete(currHash);

2
libretroshare/src/gxs/rsnxs.h
View file

@ -109,7 +109,7 @@ public:
* @param enabled set to false to disable pause, and true otherwise
* @return request token to be redeemed
*/
virtual int requestGrp(const std::list<RsGxsGroupId>& grpId, const std::string& peerId) = 0;
virtual int requestGrp(const std::list<RsGxsGroupId>& grpId, const RsPeerId& peerId) = 0;
};