Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-02-03 11:00:14 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

returned src to compilable stage

Browse Source 
added orig msgid and removed sign from nxsmsg, renamed nxsitems more appropriately 
added more code to nxs net service
removed msg versioning from data service and added extra msgField 
modified nxsitem test and datastore service appropriately, all pass 
added serialisation of transactions and added transaction number to nxsitems



git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-new_cache_system@5215 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
chrisparker126 2012-06-11 21:56:23 +00:00
parent de8f4f283c
commit 441a51757f
14 changed files with 886 additions and 391 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
libretroshare/src/gxs/rsdataservice.cc
View File

@ -25,6 +25,7 @@
// msg table columns // msg table columns
#define KEY_PUBLISH_SIGN std::string("publishSign") #define KEY_PUBLISH_SIGN std::string("publishSign")
#define KEY_MSG_ID std::string("msgId") #define KEY_MSG_ID std::string("msgId")
#define KEY_ORIG_MSG_ID std::string("origMsgId")
// grp col numbers // grp col numbers
@ -35,6 +36,7 @@
// msg col numbers // msg col numbers
#define COL_PUBLISH_SIGN 1 #define COL_PUBLISH_SIGN 1
#define COL_MSG_ID 9 #define COL_MSG_ID 9
#define COL_ORIG_MSG_ID 10
// generic col numbers // generic col numbers
#define COL_NXS_FILE 2 #define COL_NXS_FILE 2
@ -57,7 +59,7 @@ RsDataService::RsDataService(const std::string &serviceDir, const std::string &d
msgColumns.push_back(KEY_GRP_ID); msgColumns.push_back(KEY_PUBLISH_SIGN); msgColumns.push_back(KEY_NXS_FILE); msgColumns.push_back(KEY_GRP_ID); msgColumns.push_back(KEY_PUBLISH_SIGN); msgColumns.push_back(KEY_NXS_FILE);
msgColumns.push_back(KEY_NXS_FILE_OFFSET); msgColumns.push_back(KEY_NXS_FILE_LEN); msgColumns.push_back(KEY_TIME_STAMP); msgColumns.push_back(KEY_NXS_FILE_OFFSET); msgColumns.push_back(KEY_NXS_FILE_LEN); msgColumns.push_back(KEY_TIME_STAMP);
msgColumns.push_back(KEY_NXS_FLAGS); msgColumns.push_back(KEY_IDENTITY_SIGN); msgColumns.push_back(KEY_NXS_IDENTITY); msgColumns.push_back(KEY_NXS_FLAGS); msgColumns.push_back(KEY_IDENTITY_SIGN); msgColumns.push_back(KEY_NXS_IDENTITY);
msgColumns.push_back(KEY_MSG_ID); msgColumns.push_back(KEY_MSG_ID); msgColumns.push_back(KEY_ORIG_MSG_ID);
grpColumns.push_back(KEY_GRP_ID); grpColumns.push_back(KEY_ADMIN_SIGN); grpColumns.push_back(KEY_NXS_FILE); grpColumns.push_back(KEY_GRP_ID); grpColumns.push_back(KEY_ADMIN_SIGN); grpColumns.push_back(KEY_NXS_FILE);
grpColumns.push_back(KEY_NXS_FILE_OFFSET); grpColumns.push_back(KEY_NXS_FILE_LEN); grpColumns.push_back(KEY_TIME_STAMP); grpColumns.push_back(KEY_NXS_FILE_OFFSET); grpColumns.push_back(KEY_NXS_FILE_LEN); grpColumns.push_back(KEY_TIME_STAMP);
@ -77,7 +79,7 @@ void RsDataService::initialise(){
// create table for msgs // create table for msgs
mDb->execSQL("CREATE TABLE " + MSG_TABLE_NAME + "(" + KEY_MSG_ID mDb->execSQL("CREATE TABLE " + MSG_TABLE_NAME + "(" + KEY_MSG_ID
+ " TEXT," + KEY_GRP_ID + " TEXT," + KEY_NXS_FLAGS + " INT," + " TEXT," + KEY_GRP_ID + " TEXT," + KEY_NXS_FLAGS + " INT," + KEY_ORIG_MSG_ID + " TEXT,"
+ KEY_TIME_STAMP + " INT," + KEY_PUBLISH_SIGN + " BLOB," + KEY_NXS_IDENTITY + " TEXT," + KEY_TIME_STAMP + " INT," + KEY_PUBLISH_SIGN + " BLOB," + KEY_NXS_IDENTITY + " TEXT,"
+ KEY_IDENTITY_SIGN + " BLOB," + KEY_NXS_FILE + " TEXT,"+ KEY_NXS_FILE_OFFSET + " INT," + KEY_IDENTITY_SIGN + " BLOB," + KEY_NXS_FILE + " TEXT,"+ KEY_NXS_FILE_OFFSET + " INT,"
+ KEY_NXS_FILE_LEN+ " INT);"); + KEY_NXS_FILE_LEN+ " INT);");
@ -412,34 +414,6 @@ int RsDataService::retrieveMsgs(const std::string &grpId, std::map<std::string,
} }
} }
int RsDataService::retrieveMsgVersions(const std::string &grpId, const std::string& msgId,
std::set<RsNxsMsg *>& msg, bool cache){
std::string selection = KEY_GRP_ID + "='" + grpId + "' and " + KEY_MSG_ID + "='" + msgId + "'";
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, selection, "");
if(c){
bool valid = c->moveToFirst();
while(valid){
RsNxsMsg* m = getMessage(*c);
if(m)
msg.insert(m);
valid = c->moveToNext();
}
delete c;
return 1;
}else{
return 0;
}
}
int RsDataService::retrieveGrpVersions(const std::string &grpId, std::set<RsNxsGrp *> &grp, bool cache){ int RsDataService::retrieveGrpVersions(const std::string &grpId, std::set<RsNxsGrp *> &grp, bool cache){
std::string selection = KEY_GRP_ID + "='" + grpId + "'"; std::string selection = KEY_GRP_ID + "='" + grpId + "'";
@ -496,37 +470,6 @@ RsNxsGrp* RsDataService::retrieveGrpVersion(const RsGxsGrpId &grpId){
return grp; return grp;
} }
RsNxsMsg* RsDataService::retrieveMsgVersion(const RsGxsMsgId &msgId){
std::set<RsNxsMsg*> msgs;
retrieveMsgVersions(msgId.grpId, msgId.msgId, msgs, false);
RsNxsMsg* msg = NULL;
if(!msgs.empty()){
std::set<RsNxsMsg*>::iterator sit = msgs.begin();
for(; sit != msgs.end(); sit++){
msg = *sit;
if(0 == memcmp(msg->idSign.signData.bin_data, msgId.idSign.signData.bin_data,
msg->idSign.signData.bin_len))
break;
msg = NULL;
}
if(msg){
msgs.erase(msg);
for(sit = msgs.begin(); sit != msgs.end(); sit++)
delete *sit;
}
}
return msg;
}
int RsDataService::resetDataStore(){ int RsDataService::resetDataStore(){

14
libretroshare/src/gxs/rsdataservice.h
View File

@ -38,20 +38,6 @@ public:
*/ */
int retrieveGrpVersions(const std::string &grpId, std::set<RsNxsGrp *> &grp, bool cache); int retrieveGrpVersions(const std::string &grpId, std::set<RsNxsGrp *> &grp, bool cache);
/*!
* retrieves all the versions of a message for a group
* @param grpId the id of the group message belongs to
* @param msgId the id of the message to get versions for
* @return errCode
*/
int retrieveMsgVersions(const std::string &grpId, const std::string& msgId, std::set<RsNxsMsg *>& grp, bool cache);
/*!
* @param msgId the id of the message to retrieve
* @return NULL if message does not exist, or pointer to grp if found
*/
RsNxsMsg* retrieveMsgVersion(const RsGxsMsgId& msgId);
/*! /*!
* @param grpId the id of the group to retrieve * @param grpId the id of the group to retrieve
* @return NULL if group does not exist or pointer to grp if found * @return NULL if group does not exist or pointer to grp if found

24
libretroshare/src/gxs/rsgds.h
View File

@ -31,14 +31,21 @@
#include <string> #include <string>
#include "inttypes.h" #include "inttypes.h"
#include "rsgnp.h"
#include "serialiser/rsgxsitems.h" #include "serialiser/rsgxsitems.h"
#include "serialiser/rsnxsitems.h" #include "serialiser/rsnxsitems.h"
#include "gxs/rsgxs.h"
class RsGxsSearchModule {
public:
virtual ~RsGxsSearchModule();
virtual bool searchMsg(const RsGxsSearch&, RsGxsMsg* msg) = 0;
virtual bool searchGroup(const RsGxsSearch&, RsGxsGroup* grp) = 0;
};
/*! /*!
@ -93,19 +100,6 @@ public:
*/ */
virtual int retrieveGrpVersions(const std::string& grpId, std::set<RsNxsGrp*>& grp, bool cache) = 0; virtual int retrieveGrpVersions(const std::string& grpId, std::set<RsNxsGrp*>& grp, bool cache) = 0;
/*!
* @param msgId the id of the message to get versions for
* @param cache whether to store the result in memory
* @param errCode
*/
virtual int retrieveMsgVersions(const std::string& grpId, const std::string& msgId, std::set<RsNxsMsg*>& grp, bool cache) = 0;
/*!
* @param msgId the id of the message to retrieve
* @return NULL if message does not exist, or pointer to grp if found
*/
virtual RsNxsMsg* retrieveMsgVersion(const RsGxsMsgId& msgId) = 0;
/*! /*!
* @param grpId the id of the group to retrieve * @param grpId the id of the group to retrieve
* @return NULL if group does not exist or pointer to grp if found * @return NULL if group does not exist or pointer to grp if found

29
libretroshare/src/gxs/rsgxs.h
View File

@ -48,38 +48,9 @@
#define GXS_STATUS_ERROR 3 /* request is in error */ #define GXS_STATUS_ERROR 3 /* request is in error */
#define GXS_STATUS_OK 4 /* request was successful */ #define GXS_STATUS_OK 4 /* request was successful */
class RsGxsMsgId {
public:
std::string grpId;
std::string msgId;
RsTlvKeySignature idSign;
};
class RsGxsGrpId {
public:
std::string grpId;
RsTlvKeySignature adminSign;
};
typedef uint64_t RsGroupId ; typedef uint64_t RsGroupId ;
class RsGxsSearchModule {
public:
virtual bool searchMsg(const RsGxsSearch&, RsGxsMsg* msg) = 0;
virtual bool searchGroup(const RsGxsSearch&, RsGxsGroup* grp) = 0;
};
/*! /*!
* The whole idea is to provide a broad enough base class from which * The whole idea is to provide a broad enough base class from which

551
libretroshare/src/gxs/rsgxsnetservice.cc
View File

@ -2,13 +2,15 @@
RsGxsNetService::RsGxsNetService(uint16_t servType, RsGxsNetService::RsGxsNetService(uint16_t servType,
RsGeneralDataService *gds, RsNxsObserver *nxsObs) RsGeneralDataService *gds, RsNxsObserver *nxsObs)
: mServType(servType), mDataStore(gds), mObserver(nxsObs) : p3Config(servType), mServType(servType), mDataStore(gds),
mObserver(nxsObs), mNxsMutex("RsGxsNetService")
{ {
} }
void RsGxsNetService::tick(){ int RsGxsNetService::tick(){
if(receivedItems()) if(receivedItems())
@ -34,7 +36,7 @@ void RsGxsNetService::recvNxsItemQueue(){
if(ni->transactionNumber != 0){ if(ni->transactionNumber != 0){
// accumulate // accumulate
if(handleTransactionContent(ci)) if(handleTransaction(ni))
delete ni ; delete ni ;
continue ; // don't delete! It's handled by handleRecvChatMsgItem in some specific cases only. continue ; // don't delete! It's handled by handleRecvChatMsgItem in some specific cases only.
@ -43,11 +45,10 @@ void RsGxsNetService::recvNxsItemQueue(){
switch(ni->PacketSubType()) switch(ni->PacketSubType())
{ {
case RS_PKT_SUBTYPE_NXS_SYNC_GRP: handleRecvSyncGroup (dynamic_cast<RsSyncGrp*>(ni)) ; break ; case RS_PKT_SUBTYPE_NXS_SYNC_GRP: handleRecvSyncGroup (dynamic_cast<RsNxsSyncGrp*>(ni)) ; break ;
case RS_PKT_SUBTYPE_NXS_SYNC_MSG: handleRecvSyncMessage (dynamic_cast<RsSyncGrpMsg*>(ni)) ; break ; case RS_PKT_SUBTYPE_NXS_SYNC_MSG: handleRecvSyncMessage (dynamic_cast<RsNxsSyncMsg*>(ni)) ; break ;
case RS_PKT_SUBTYPE_NXS_TRANS: handleRecvTransaction (dynamic_cast<RsNxsTransac*>(ni)) ; break;
default: default:
std::cerr << "Unhandled item subtype " << ni->PacketSubType() << " in RsGxsNetService: " << std::endl; std::cerr << "Unhandled item subtype " << ni->PacketSubType() << " in RsGxsNetService: " << std::endl; break;
} }
delete item ; delete item ;
} }
@ -55,6 +56,137 @@ void RsGxsNetService::recvNxsItemQueue(){
} }
bool RsGxsNetService::handleTransaction(RsNxsItem* item){
/*!
* This attempts to handle a transaction
* It first checks if this transaction id already exists
* If it does then create check this not a initiating transactions
*/
RsStackMutex stack(mNxsMutex);
const std::string& peer = item->PeerId();
RsNxsTransac* transItem = dynamic_cast<RsNxsTransac*>(item);
// if this is an RsNxsTransac item process
if(transItem){
return locked_processTransac(transItem);
}
// then this must be transaction content to be consumed
// first check peer exist for transaction
bool peerTransExists = mTransactions.find(peer) == mTransactions.end();
// then check transaction exists
bool transExists = false;
NxsTransaction* tr = NULL;
uint32_t transN = item->transactionNumber;
bool complete = false;
if(peerTransExists)
{
TransactionIdMap& transMap = mTransactions[peer];
transExists = transMap.find(transN) != transMap.end();
if(transExists){
tr = transMap[transN];
tr->mItems.push_back(item);
}
}else{
return false;
}
return true;
}
bool RsGxsNetService::locked_processTransac(RsNxsTransac* item)
{
const std::string& peer = item->PeerId();
uint32_t transN = item->transactionNumber;
NxsTransaction* tr = NULL;
bool peerTrExists = mTransactions.find(peer) != mTransactions.end();
bool transExists = false;
if(peerTrExists){
TransactionIdMap& transMap = mTransactions[peer];
// remove current transaction if it does exist
transExists = transMap.find(transN) != transMap.end();
}
if(item->transactFlag & RsNxsTransac::FLAG_BEGIN_P1){
// create a transaction if the peer does not exist
if(!peerTrExists){
mTransactions[peer] = TransactionIdMap();
}
TransactionIdMap& transMap = mTransactions[peer];
if(transExists)
{
delete transMap[transN];
transMap.erase(transN);
}
// create new transaction
tr = new NxsTransaction();
transMap[transN] = tr;
tr->mTransaction = item;
tr->mTimestamp = time(NULL);
// note state as receiving
tr->mFlag = NxsTransaction::FLAG_STATE_STARTING;
}else if(item->transactFlag & RsNxsTransac::FLAG_BEGIN_P2){
// transaction must already exist
if(!peerTrExists || !transExists){
delete item;
return false;
}
// this means you need to start a transaction
TransactionIdMap& transMap = mTransactions[mOwnId];
NxsTransaction* tr = transMap[transN];
tr->mFlag = NxsTransaction::FLAG_STATE_SENDING;
}else if(item->transactFlag & RsNxsTransac::FLAG_END_SUCCESS){
// transaction must already exist
if(!peerTrExists || !transExists){
delete item;
return false;
}
// this means you need to start a transaction
TransactionIdMap& transMap = mTransactions[mOwnId];
NxsTransaction* tr = transMap[transN];
tr->mFlag = NxsTransaction::FLAG_STATE_COMPLETED;
}else{ // any other flag indicates a failure
// transaction must already exist
if(!peerTrExists || !transExists){
delete item;
return false;
}
// this means you need to start a transaction
TransactionIdMap& transMap = mTransactions[mOwnId];
NxsTransaction* tr = transMap[transN];
tr->mFlag = NxsTransaction::FLAG_STATE_FAILED;
}
return true;
} }
void RsGxsNetService::run(){ void RsGxsNetService::run(){
@ -72,23 +204,421 @@ void RsGxsNetService::run(){
processTransactions(); processTransactions();
processCompleteTransactions(); processCompletedTransactions();
processSyncRequests(); processSyncRequests();
} }
} }
void RsGxsNetService::recvItem(){
void RsGxsNetService::processTransactions(){
TransactionsPeerMap::iterator mit = mTransactions.begin();
for(; mit != mTransactions.end(); mit++){
TransactionIdMap& transMap = mit->second;
TransactionIdMap::iterator mmit = transMap.begin(),
mmit_end = transMap.end();
if(mit->first == mOwnId){
std::list<uint32_t> toRemove;
for(; mmit != mmit_end; mmit++){
NxsTransaction* tr = mmit->second;
uint16_t flag = tr->mFlag;
std::list<RsNxsItem*>::iterator lit, lit_end;
uint32_t transN = tr->mTransaction->transactionNumber;
// send items requested
if(flag & NxsTransaction::FLAG_STATE_SENDING){
lit = tr->mItems.begin();
lit_end = tr->mItems.end();
for(; lit != lit_end; lit++){
sendItem(*lit);
}
tr->mItems.clear();
tr->mFlag = NxsTransaction::FLAG_STATE_WAITING_CONFIRM;
}else if(flag & NxsTransaction::FLAG_STATE_WAITING_CONFIRM){
continue;
}else if(flag & NxsTransaction::FLAG_STATE_COMPLETED){
// move to completed transactions
toRemove.push_back(transN);
mComplTransactions.push_back(tr);
}
}
std::list<uint32_t>::iterator lit = toRemove.begin();
for(; lit != toRemove.end(); lit++)
{
transMap.erase(*lit);
}
}else{
/*!
* Essentially these are incoming transactions
* Several states are dealth with
* Receiving: waiting to receive items from peer's transaction
* and checking if all have been received
* Completed: remove transaction from active and tell peer
* involved in transaction
* Starting: this is a new transaction and need to teell peer
* involved in transaction
*/
std::list<uint32_t> toRemove;
for(; mmit != mmit_end; mmit++){
NxsTransaction* tr = mmit->second;
uint16_t flag = tr->mFlag;
uint32_t transN = tr->mTransaction->transactionNumber;
if(flag & NxsTransaction::FLAG_STATE_RECEIVING){
// check if done
if(tr->mItems.size() == tr->mTransaction->nItems)
tr->mFlag = NxsTransaction::FLAG_STATE_COMPLETED;
}else if(flag & NxsTransaction::FLAG_STATE_COMPLETED)
{
// send completion msg
RsNxsTransac* trans = new RsNxsTransac(mServType);
trans->clear();
trans->transactFlag = RsNxsTransac::FLAG_END_SUCCESS;
trans->transactionNumber = transN;
trans->PeerId(tr->mTransaction->PeerId());
sendItem(trans);
// move to completed transactions
mComplTransactions.push_back(tr);
// transaction processing done
// for this id, add to removal list
toRemove.push_back(mmit->first);
}else if(flag & NxsTransaction::FLAG_STATE_STARTING){
// send item to tell peer your are ready to start
RsNxsTransac* trans = new RsNxsTransac(mServType);
trans->clear();
trans->transactFlag = RsNxsTransac::FLAG_BEGIN_P2;
trans->transactionNumber = transN;
trans->PeerId(tr->mTransaction->PeerId());
}
else{
// if no state
std::cerr << "RsGxsNetService::processTransactions() Unrecognised statem, deleting " << std::endl;
std::cerr << "RsGxsNetService::processTransactions() Id: "
<< transN << std::endl;
toRemove.push_back(transN);
}
}
std::list<uint32_t>::iterator lit = toRemove.begin();
for(; lit != toRemove.end(); lit++)
{
transMap.erase(*lit);
}
}
}
}
void RsGxsNetService::processCompletedTransactions()
{
/*!
* Depending on transaction we may have to respond to peer
* responsible for transaction
*/
std::list<NxsTransaction*>::iterator lit = mComplTransactions.begin();
while(mComplTransactions.size()>0)
{
NxsTransaction* tr = mComplTransactions.front();
uint16_t flag = tr->mTransaction->transactFlag;
if(flag & RsNxsTransac::FLAG_TYPE_MSG_LIST_RESP)
{
// generate request based on a peers response
genReqMsgTransaction(tr);
}else if(flag & RsNxsTransac::FLAG_TYPE_GRP_LIST_RESP)
{
genReqGrpTransaction(tr);
}
else if( (flag & RsNxsTransac::FLAG_TYPE_MSG_LIST_REQ) ||
(flag & RsNxsTransac::FLAG_TYPE_GRP_LIST_REQ) )
{
// don't do anything
}else if(flag & RsNxsTransac::FLAG_TYPE_GRPS)
{
std::list<RsNxsItem*>::iterator lit = tr->mItems.begin();
std::list<RsNxsGrp*> grps;
for(; lit != tr->mItems.end(); lit++)
{
RsNxsGrp* grp = dynamic_cast<RsNxsGrp*>(*lit);
if(grp){
grps.push_back(grp);
}else{
#ifdef NXS_NET_DEBUG
std::cerr << "RsGxsNetService::processCompletedTransactions(): item did not caste to grp"
<< std::endl;
#endif
}
}
// notify listener of grps
notifyListenerGrps(grps);
}else if(flag & RsNxsTransac::FLAG_TYPE_MSGS)
{
std::list<RsNxsItem*>::iterator lit = tr->mItems.begin();
std::list<RsNxsMsg*> msgs;
for(; lit != tr->mItems.end(); lit++)
{
RsNxsMsg* msg = dynamic_cast<RsNxsMsg*>(*lit);
if(msg){
msgs.push_back(msg);
}else{
#ifdef NXS_NET_DEBUG
std::cerr << "RsGxsNetService::processCompletedTransactions(): item did not caste to msg"
<< std::endl;
#endif
}
}
// notify listener of msgs
notifyListenerMsgs(msgs);
}
tr->mItems.clear();
delete tr;
mComplTransactions.pop_front();
}
} }
void RsGxsNetService::genReqMsgTransaction(NxsTransaction* tr)
{
// to create a transaction you need to know who you are transacting with
// then what msgs to request
// then add an active Transaction for request
std::list<RsNxsSyncMsgItem*> msgItemL;
std::list<RsNxsItem*>::iterator lit = tr->mItems.begin();
for(; lit != tr->mItems.end(); lit++)
{
RsNxsSyncMsgItem* item = dynamic_cast<RsNxsSyncMsgItem*>(*lit);
if(item)
{
msgItemL.push_back(item);
}else
{
#ifdef NXS_NET_DEBUG
std::cerr << "RsGxsNetService::genReqMsgTransaction(): item failed to caste to RsNxsSyncMsgItem* "
<< std::endl;
#endif
delete item;
item = NULL;
}
}
RsNxsSyncMsgItem* item = msgItemL.front();
const std::string& grpId = item->grpId;
std::map<std::string, RsNxsMsg*> msgMap;
mDataStore->retrieveMsgs(grpId, msgMap, false);
// now do compare and add loop
std::list<RsNxsSyncMsgItem*>::iterator llit = msgItemL.begin();
std::list<RsNxsItem*> reqList;
uint32_t transN = getTransactionId();
for(; llit != msgItemL.end(); llit++)
{
const std::string& msgId = (*llit)->msgId;
if(msgMap.find(msgId) == msgMap.end()){
RsNxsSyncMsgItem* msgItem = new RsNxsSyncMsgItem(mServType);
msgItem->grpId = grpId;
msgItem->msgId = msgId;
msgItem->flag = RsNxsSyncMsgItem::FLAG_REQUEST;
msgItem->transactionNumber = transN;
reqList.push_back(msgItem);
}
}
RsNxsTransac* transac = new RsNxsTransac(mServType);
transac->transactFlag = RsNxsTransac::FLAG_TYPE_MSG_LIST_REQ
| RsNxsTransac::FLAG_BEGIN_P1;
transac->timeout = mTransactionTimeOut;
transac->nItems = reqList.size();
NxsTransaction* newTrans = new NxsTransaction();
newTrans->mItems = reqList;
newTrans->mFlag = NxsTransaction::FLAG_STATE_STARTING;
newTrans->mTimestamp = 0;
newTrans->mTransaction = transac;
{
RsStackMutex stack(mNxsMutex);
if(!locked_addTransaction(newTrans))
delete newTrans;
}
}
void RsGxsNetService::genReqGrpTransaction(NxsTransaction* tr)
{
// to create a transaction you need to know who you are transacting with
// then what grps to request
// then add an active Transaction for request
std::list<RsNxsSyncGrpItem*> grpItemL;
std::list<RsNxsItem*>::iterator lit = tr->mItems.begin();
for(; lit != tr->mItems.end(); lit++)
{
RsNxsSyncGrpItem* item = dynamic_cast<RsNxsSyncGrpItem*>(*lit);
if(item)
{
grpItemL.push_back(item);
}else
{
#ifdef NXS_NET_DEBUG
std::cerr << "RsGxsNetService::genReqMsgTransaction(): item failed to caste to RsNxsSyncMsgItem* "
<< std::endl;
#endif
delete item;
item = NULL;
}
}
RsNxsSyncGrpItem* item = grpItemL.front();
const std::string& grpId = item->grpId;
std::map<std::string, RsNxsGrp*> grpMap;
mDataStore->retrieveGrps(grpMap, false);
// now do compare and add loop
std::list<RsNxsSyncGrpItem*>::iterator llit = grpItemL.begin();
std::list<RsNxsItem*> reqList;
uint32_t transN = getTransactionId();
for(; llit != grpItemL.end(); llit++)
{
const std::string& grpId = (*llit)->grpId;
if(grpMap.find(grpId) == grpMap.end()){
RsNxsSyncGrpItem* grpItem = new RsNxsSyncGrpItem(mServType);
grpItem->grpId = grpId;
grpItem->flag = RsNxsSyncMsgItem::FLAG_REQUEST;
grpItem->transactionNumber = transN;
reqList.push_back(grpItem);
}
}
RsNxsTransac* transac = new RsNxsTransac(mServType);
transac->transactFlag = RsNxsTransac::FLAG_TYPE_MSG_LIST_REQ
| RsNxsTransac::FLAG_BEGIN_P1;
transac->timeout = mTransactionTimeOut;
transac->nItems = reqList.size();
NxsTransaction* newTrans = new NxsTransaction();
newTrans->mItems = reqList;
newTrans->mFlag = NxsTransaction::FLAG_STATE_STARTING;
newTrans->mTimestamp = 0;
newTrans->mTransaction = transac;
{
RsStackMutex stack(mNxsMutex);
if(!locked_addTransaction(newTrans))
delete newTrans;
}
}
bool RsGxsNetService::locked_addTransaction(NxsTransaction* tr)
{
const std::string& peer = tr->mTransaction->PeerId();
uint32_t transN = tr->mTransaction->transactionNumber;
TransactionIdMap& transMap = mTransactions[peer];
bool transNumExist = transMap.find(transN)
!= transMap.end();
if(transNumExist){
return false;
}else{
transMap[transN] = tr;
return true;
}
}
void RsGxsNetService::cleanTransactionItems(NxsTransaction* tr) const
{
std::list<RsNxsItem*>::iterator lit = tr->mItems.begin();
for(; lit != tr->mItems.end(); lit++)
{
delete *lit;
}
tr->mItems.clear();
}
/** inherited methods **/
void RsGxsNetService::pauseSynchronisation(bool enabled)
{
}
void RsGxsNetService::subscribeToGroup(const std::string& grpId, bool subscribe)
{
}
void RsGxsNetService::setSyncAge(uint32_t age)
{
}
/** NxsTransaction definition **/ /** NxsTransaction definition **/
NxsTransaction::NxsTransaction() NxsTransaction::NxsTransaction()
:mTransaction(NULL), mFlag(0), mTimestamp(0) { :mTransaction(NULL), mFlag(0), mTimestamp(0) {
@ -96,4 +626,5 @@ NxsTransaction::NxsTransaction()
NxsTransaction::~NxsTransaction(){ NxsTransaction::~NxsTransaction(){
delete mTransaction;
} }

148
libretroshare/src/gxs/rsgxsnetservice.h
View File

@ -16,16 +16,20 @@
/*! /*!
* This represents a transaction made * This represents a transaction made
* with the NxsNetService in all states * with the NxsNetService in all states
* of operation untill completion * of operation until completion
*/ */
class NxsTransaction class NxsTransaction
{ {
public: public:
static const uint8_t FLAG_STATE_RECEIVING; static const uint8_t FLAG_STATE_STARTING; // when
static const uint8_t FLAG_STATE_DONE; static const uint8_t FLAG_STATE_RECEIVING; // begin receiving items for incoming trans
static const uint8_t FLGA_STATE_COMPLETED; static const uint8_t FLAG_STATE_SENDING; // begin sending items for outgoing trans
static const uint8_t FLAG_STATE_COMPLETED;
static const uint8_t FLAG_STATE_FAILED;
static const uint8_t FLAG_STATE_WAITING_CONFIRM;
NxsTransaction(); NxsTransaction();
~NxsTransaction(); ~NxsTransaction();
@ -45,6 +49,20 @@ public:
std::list<RsNxsItem*> mItems; // items received or sent std::list<RsNxsItem*> mItems; // items received or sent
}; };
class NxsGrpSyncTrans : public NxsTransaction {
public:
};
class NxsMsgSyncTrans : public NxsTransaction {
public:
std::string mGrpId;
};
/// keep track of transaction number /// keep track of transaction number
typedef std::map<uint32_t, NxsTransaction*> TransactionIdMap; typedef std::map<uint32_t, NxsTransaction*> TransactionIdMap;
@ -84,7 +102,7 @@ public:
* Circumvents polling of peers for message * Circumvents polling of peers for message
* @param peerId id of peer * @param peerId id of peer
*/ */
void requestGroupsOfPeer(const std::string& peerId); void requestGroupsOfPeer(const std::string& peerId){ return;}
/*! /*!
* get messages of a peer for a given group id, this circumvents the normal * get messages of a peer for a given group id, this circumvents the normal
@ -92,7 +110,7 @@ public:
* @param peerId Id of peer * @param peerId Id of peer
* @param grpId id of group to request messages for * @param grpId id of group to request messages for
*/ */
void requestMessagesOfPeer(const std::string& peerId, const RsGroupId& grpId); void requestMessagesOfPeer(const std::string& peerId, const RsGxsGrpId& grpId){ return; }
/*! /*!
* subscribes the associated service to this group. This RsNetworktExchangeService * subscribes the associated service to this group. This RsNetworktExchangeService
@ -100,7 +118,7 @@ public:
* @param grpId the id of the group to subscribe to * @param grpId the id of the group to subscribe to
* @param subscribe set to true to subscribe or false to unsubscribe * @param subscribe set to true to subscribe or false to unsubscribe
*/ */
void subscribeToGroup(const RsGroupId& grpId, bool subscribe); void subscribeToGroup(const std::string& grpId, bool subscribe);
/*! /*!
* Initiates a search through the network * Initiates a search through the network
@ -109,7 +127,7 @@ public:
* @param hops how far into friend tree for search * @param hops how far into friend tree for search
* @return search token that can be redeemed later, implementation should indicate how this should be used * @return search token that can be redeemed later, implementation should indicate how this should be used
*/ */
int searchMsgs(RsGxsSearch* search, uint8_t hops = 1, bool retrieve = 0); int searchMsgs(RsGxsSearch* search, uint8_t hops = 1, bool retrieve = 0){ return 0;}
/*! /*!
* Initiates a search of groups through the network which goes * Initiates a search of groups through the network which goes
@ -118,7 +136,7 @@ public:
* @param hops number of hops deep into peer network * @param hops number of hops deep into peer network
* @return search token that can be redeemed later * @return search token that can be redeemed later
*/ */
int searchGrps(RsGxsSearch* search, uint8_t hops = 1, bool retrieve = 0); int searchGrps(RsGxsSearch* search, uint8_t hops = 1, bool retrieve = 0){ return 0;}
/*! /*!
@ -135,7 +153,7 @@ public:
* @param msgId the messages to retrieve * @param msgId the messages to retrieve
* @return request token to be redeemed * @return request token to be redeemed
*/ */
int requestMsg(const std::list<RsGxsMsgId>& msgId, uint8_t hops); int requestMsg(const std::string& msgId, uint8_t hops){ return 0;}
/*! /*!
* Request for this group is sent through to peers on your network * Request for this group is sent through to peers on your network
@ -143,7 +161,7 @@ public:
* @param enabled set to false to disable pause, and true otherwise * @param enabled set to false to disable pause, and true otherwise
* @return request token to be redeemed * @return request token to be redeemed
*/ */
int requestGrp(const std::list<RsGxsGrpId>& grpId, uint8_t hops); int requestGrp(const std::list<RsGxsGrpId>& grpId, uint8_t hops){ return 0;}
@ -152,7 +170,7 @@ public:
/*! /*!
* initiates synchronisation * initiates synchronisation
*/ */
void tick(); int tick();
/*! /*!
* Processes transactions and job queue * Processes transactions and job queue
@ -168,25 +186,34 @@ private:
void recvNxsItemQueue(); void recvNxsItemQueue();
/*! /*!
* Processes active tansaction map * Processes synchronisation requests. If request is valid this generates
* msg/grp response transaction with sending peer
*/
void processSyncRequests();
/** S: Transaction processing **/
/*!
* These process transactions which are in a wait state
* Also moves transaction which have been completed to
* the completed transactions list
*/ */
void processTransactions(); void processTransactions();
/*! /*!
* Process completed transaction map * Process completed transaction, which either simply
* retires a transaction or additionally generates a response
* to the completed transaction
*/ */
void processCompleteTransactions(); void processCompletedTransactions();
/*! /*!
* Processes synchronisation requests * Process a transaction item, assumes a general lock
* @param item the transaction item to process
*/ */
void processSyncRequests(); bool locked_processTransac(RsNxsTransac* item);
/*!
* This adds a transaction to
* @param
*/
void locked_addTransaction(NxsTransaction* trans);
/*! /*!
* This adds a transaction * This adds a transaction
@ -197,21 +224,72 @@ private:
*/ */
void locked_completeTransaction(NxsTransaction* trans); void locked_completeTransaction(NxsTransaction* trans);
/*!
* This retrieves a unique transaction id that
* can be used in an outgoing transaction
*/
uint32_t getTransactionId(); uint32_t getTransactionId();
/*!
* This attempts to push the transaction id counter back if you have
* active outgoing transactions in play
*/
bool attemptRecoverIds(); bool attemptRecoverIds();
/** item handlers **/ /*!
* The cb listener is the owner of the grps
* @param grps
*/
void notifyListenerGrps(std::list<RsNxsGrp*>& grps);
void handleTransactionContent(RsNxsItem*); /*!
* The cb listener is the owner of the msgs
* @param msgs
*/
void notifyListenerMsgs(std::list<RsNxsMsg*>& msgs);
void handleRecvSyncGroup(RsSyncGrp*); /*!
* @param tr transaction responsible for generating msg request
*/
void genReqMsgTransaction(NxsTransaction* tr);
void handleRecvSyncMessage(RsNxsItem*); /*!
* @param tr transaction responsible for generating grp request
*/
void genReqGrpTransaction(NxsTransaction* tr);
void handleRecvTransaction(RsNxsItem*); /*!
* @param tr transaction to add
*/
bool locked_addTransaction(NxsTransaction* tr);
/** item handlers **/ void cleanTransactionItems(NxsTransaction* tr) const;
/** E: Transaction processing **/
/** S: item handlers **/
/*!
* This attempts handles transaction items
* ownership of item is left with callee if this method returns false
* @param item transaction item to handle
* @return false if transaction could not be handled, ownership of item is left with callee
*/
bool handleTransaction(RsNxsItem* item);
/*!
* Handles an nxs item for group synchronisation
* @param item contaims grp sync info
*/
void handleRecvSyncGroup(RsNxsSyncGrp* item);
/*!
* Handles an nxs item for msgs synchronisation
* @param item contaims msg sync info
*/
void handleRecvSyncMessage(RsNxsSyncMsg* item);
/** E: item handlers **/
private: private:
@ -219,7 +297,7 @@ private:
/*** transactions ***/ /*** transactions ***/
/// active transactions /// active transactions
TransactionsPeerMap mInTransactions; TransactionsPeerMap mTransactions;
/// completed transactions /// completed transactions
std::list<NxsTransaction*> mComplTransactions; std::list<NxsTransaction*> mComplTransactions;
@ -230,17 +308,17 @@ private:
/*** transactions ***/ /*** transactions ***/
/*** synchronisation ***/ /*** synchronisation ***/
std::list<RsSyncGrp*> mSyncGrp; std::list<RsNxsSyncGrp*> mSyncGrp;
std::list<RsSyncGrpMsg*> mSyncMsg; std::list<RsNxsSyncMsg*> mSyncMsg;
/*** synchronisation ***/ /*** synchronisation ***/
RsNxsObserver* mObserver; RsNxsObserver* mObserver;
RsGeneralDataService* mDataStore; RsGeneralDataService* mDataStore;
uint16_t mServType; uint16_t mServType;
uint32_t mTransactionTimeOut;
std::string mOwnId;
/// for transaction members ;
RsMutex mTransMutex;
/// for other members save transactions /// for other members save transactions
RsMutex mNxsMutex; RsMutex mNxsMutex;

10
libretroshare/src/gxs/rsnxs.h
View File

@ -33,8 +33,8 @@
#include <list> #include <list>
#include <map> #include <map>
#include "gxs/rsgxs.h"
#include "services/p3service.h" #include "services/p3service.h"
#include "rsgds.h"
/*! /*!
* Retroshare General Network Exchange Service: \n * Retroshare General Network Exchange Service: \n
@ -60,6 +60,8 @@ class RsNetworkExchangeService : public p3Service
{ {
public: public:
RsNetworkExchangeService();
/*! /*!
* Use this to set how far back synchronisation of messages should take place * Use this to set how far back synchronisation of messages should take place
* @param age the max age a sync item can to be allowed in a synchronisation * @param age the max age a sync item can to be allowed in a synchronisation
@ -79,7 +81,7 @@ public:
* @param peerId Id of peer * @param peerId Id of peer
* @param grpId id of group to request messages for * @param grpId id of group to request messages for
*/ */
virtual void requestMessagesOfPeer(const std::string& peerId, const RsGroupId& grpId); virtual void requestMessagesOfPeer(const std::string& peerId, const RsGxsGrpId& grpId) = 0;
/*! /*!
* subscribes the associated service to this group. This RsNetworktExchangeService * subscribes the associated service to this group. This RsNetworktExchangeService
@ -87,7 +89,7 @@ public:
* @param grpId the id of the group to subscribe to * @param grpId the id of the group to subscribe to
* @param subscribe set to true to subscribe or false to unsubscribe * @param subscribe set to true to subscribe or false to unsubscribe
*/ */
virtual void subscribeToGroup(const RsGroupId& grpId, bool subscribe) = 0; virtual void subscribeToGroup(const std::string& grpId, bool subscribe) = 0;
/*! /*!
* Initiates a search through the network * Initiates a search through the network
@ -122,7 +124,7 @@ public:
* @param msgId the messages to retrieve * @param msgId the messages to retrieve
* @return request token to be redeemed * @return request token to be redeemed
*/ */
virtual int requestMsg(const std::list<RsGxsMsgId>& msgId, uint8_t hops) = 0; virtual int requestMsg(const std::string& msgId, uint8_t hops) = 0;
/*! /*!
* Request for this group is sent through to peers on your network * Request for this group is sent through to peers on your network

6
libretroshare/src/libretroshare.pro
View File

@ -666,11 +666,13 @@ newcache {
HEADERS += serialiser/rsnxsitems.h \ HEADERS += serialiser/rsnxsitems.h \
gxs/rsgds.h \ gxs/rsgds.h \
gxs/rsgxs.h \ gxs/rsgxs.h \
gxs/rsdataservice/h gxs/rsdataservice/h \
gxs/rsgxsnetservice.h
SOURCES += serialiser/rsnxsitems.cc \ SOURCES += serialiser/rsnxsitems.cc \
gxs/rsdataservice.cc \ gxs/rsdataservice.cc \
gxs/rsgenexchange.cc gxs/rsgenexchange.cc \
gxs/rsgxsnetservice.cc
} }

256
libretroshare/src/serialiser/rsnxsitems.cc
View File

@ -2,51 +2,57 @@
#include "rsbaseserial.h" #include "rsbaseserial.h"
#define RSSERIAL_DEBUG #define RSSERIAL_DEBUG
const uint8_t RsSyncGrpList::FLAG_REQUEST = 0x001; const uint8_t RsNxsSyncGrpItem::FLAG_REQUEST = 0x001;
const uint8_t RsSyncGrpList::FLAG_RESPONSE = 0x002; const uint8_t RsNxsSyncGrpItem::FLAG_RESPONSE = 0x002;
const uint8_t RsSyncGrpMsgList::FLAG_REQUEST = 0x001; const uint8_t RsNxsSyncMsgItem::FLAG_REQUEST = 0x001;
const uint8_t RsSyncGrpMsgList::FLAG_RESPONSE = 0x002; const uint8_t RsNxsSyncMsgItem::FLAG_RESPONSE = 0x002;
const uint8_t RsSyncGrp::FLAG_USE_SYNC_HASH = 0x001; const uint8_t RsNxsSyncGrp::FLAG_USE_SYNC_HASH = 0x001;
const uint8_t RsSyncGrpMsg::FLAG_USE_SYNC_HASH = 0x001; const uint8_t RsNxsSyncMsg::FLAG_USE_SYNC_HASH = 0x001;
uint32_t RsNxsSerialiser::size(RsItem *item) { uint32_t RsNxsSerialiser::size(RsItem *item) {
RsNxsGrp* ngp; RsNxsGrp* ngp;
RsNxsMsg* nmg; RsNxsMsg* nmg;
RsSyncGrp* sg; RsNxsSyncGrp* sg;
RsSyncGrpList* sgl; RsNxsSyncGrpItem* sgl;
RsSyncGrpMsg* sgm; RsNxsSyncMsg* sgm;
RsSyncGrpMsgList* sgml; RsNxsSyncMsgItem* sgml;
RsNxsTransac* ntx; RsNxsTransac* ntx;
if((sg = dynamic_cast<RsSyncGrp*>(item)) != NULL) if((sg = dynamic_cast<RsNxsSyncGrp*>(item)) != NULL)
{ {
return sizeSyncGrp(sg); return sizeNxsSyncGrp(sg);
}else if(( ntx = dynamic_cast<RsNxsTransac*>(item)) != NULL){ }else if(( ntx = dynamic_cast<RsNxsTransac*>(item)) != NULL){
return sizeNxsTrans(ntx); return sizeNxsTrans(ntx);
} }
else if ((sgl = dynamic_cast<RsSyncGrpList*>(item)) != NULL) else if ((sgl = dynamic_cast<RsNxsSyncGrpItem*>(item)) != NULL)
{ {
return sizeSyncGrpList(sgl); return sizeNxsSyncGrpItem(sgl);
}else if ((sgm = dynamic_cast<RsSyncGrpMsg*>(item)) != NULL) }else if ((sgm = dynamic_cast<RsNxsSyncMsg*>(item)) != NULL)
{ {
return sizeSyncGrpMsg(sgm); return sizeNxsSyncMsg(sgm);
}else if ((sgml = dynamic_cast<RsSyncGrpMsgList*>(item)) != NULL) }else if ((sgml = dynamic_cast<RsNxsSyncMsgItem*>(item)) != NULL)
{ {
return sizeSyncGrpMsgList(sgml); return sizeNxsSyncMsgItem(sgml);
}else if((ngp = dynamic_cast<RsNxsGrp*>(item)) != NULL) }else if((ngp = dynamic_cast<RsNxsGrp*>(item)) != NULL)
{ {
return sizeNxsGrp(ngp); return sizeNxsGrp(ngp);
}else if((nmg = dynamic_cast<RsNxsMsg*>(item)) != NULL) }else if((nmg = dynamic_cast<RsNxsMsg*>(item)) != NULL)
{ {
return sizeNxsMsg(nmg); return sizeNxsMsg(nmg);
}else{
#ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::size(): Could not find appropriate size function"
<< std::endl;
#endif
return 0;
} }
} }
@ -70,13 +76,13 @@ RsItem* RsNxsSerialiser::deserialise(void *data, uint32_t *size) {
{ {
case RS_PKT_SUBTYPE_NXS_SYNC_GRP: case RS_PKT_SUBTYPE_NXS_SYNC_GRP:
return deserialSyncGrp(data, size); return deserialNxsSyncGrp(data, size);
case RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM: case RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM:
return deserialSyncGrpList(data, size); return deserialNxsSyncGrpItem(data, size);
case RS_PKT_SUBTYPE_NXS_SYNC_MSG: case RS_PKT_SUBTYPE_NXS_SYNC_MSG:
return deserialSyncGrpMsg(data, size); return deserialNxsSyncMsg(data, size);
case RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM: case RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM:
return deserialSyncGrpMsgList(data, size); return deserialNxsSyncMsgItem(data, size);
case RS_PKT_SUBTYPE_NXS_GRP: case RS_PKT_SUBTYPE_NXS_GRP:
return deserialNxsGrp(data, size); return deserialNxsGrp(data, size);
case RS_PKT_SUBTYPE_NXS_MSG: case RS_PKT_SUBTYPE_NXS_MSG:
@ -103,31 +109,31 @@ bool RsNxsSerialiser::serialise(RsItem *item, void *data, uint32_t *size){
RsNxsGrp* ngp; RsNxsGrp* ngp;
RsNxsMsg* nmg; RsNxsMsg* nmg;
RsSyncGrp* sg; RsNxsSyncGrp* sg;
RsSyncGrpList* sgl; RsNxsSyncGrpItem* sgl;
RsSyncGrpMsg* sgm; RsNxsSyncMsg* sgm;
RsSyncGrpMsgList* sgml; RsNxsSyncMsgItem* sgml;
RsNxsExtended* nxt; RsNxsExtended* nxt;
RsNxsTransac* ntx; RsNxsTransac* ntx;
if((sg = dynamic_cast<RsSyncGrp*>(item)) != NULL) if((sg = dynamic_cast<RsNxsSyncGrp*>(item)) != NULL)
{ {
return serialiseSyncGrp(sg, data, size); return serialiseNxsSyncGrp(sg, data, size);
}else if ((ntx = dynamic_cast<RsNxsTransac*>(item)) != NULL) }else if ((ntx = dynamic_cast<RsNxsTransac*>(item)) != NULL)
{ {
return serialiseNxsTrans(ntx, data, size); return serialiseNxsTrans(ntx, data, size);
}else if ((sgl = dynamic_cast<RsSyncGrpList*>(item)) != NULL) }else if ((sgl = dynamic_cast<RsNxsSyncGrpItem*>(item)) != NULL)
{ {
return serialiseSyncGrpList(sgl, data, size); return serialiseNxsSyncGrpItem(sgl, data, size);
}else if ((sgm = dynamic_cast<RsSyncGrpMsg*>(item)) != NULL) }else if ((sgm = dynamic_cast<RsNxsSyncMsg*>(item)) != NULL)
{ {
return serialiseSyncGrpMsg(sgm, data, size); return serialiseNxsSyncMsg(sgm, data, size);
}else if ((sgml = dynamic_cast<RsSyncGrpMsgList*>(item)) != NULL) }else if ((sgml = dynamic_cast<RsNxsSyncMsgItem*>(item)) != NULL)
{ {
return serialiseSynGrpMsgList(sgml, data, size); return serialiseNxsSynMsgItem(sgml, data, size);
}else if((ngp = dynamic_cast<RsNxsGrp*>(item)) != NULL) }else if((ngp = dynamic_cast<RsNxsGrp*>(item)) != NULL)
{ {
return serialiseNxsGrp(ngp, data, size); return serialiseNxsGrp(ngp, data, size);
@ -148,18 +154,18 @@ bool RsNxsSerialiser::serialise(RsItem *item, void *data, uint32_t *size){
} }
bool RsNxsSerialiser::serialiseSynGrpMsgList(RsSyncGrpMsgList *item, void *data, uint32_t *size){ bool RsNxsSerialiser::serialiseNxsSynMsgItem(RsNxsSyncMsgItem *item, void *data, uint32_t *size){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSynGrpMsgList()" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem()" << std::endl;
#endif #endif
uint32_t tlvsize = sizeSyncGrpMsgList(item); uint32_t tlvsize = sizeNxsSyncMsgItem(item);
uint32_t offset = 0; uint32_t offset = 0;
if(*size < tlvsize){ if(*size < tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSynGrpMsgList()" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem()" << std::endl;
#endif #endif
return false; return false;
} }
@ -173,17 +179,16 @@ bool RsNxsSerialiser::serialiseSynGrpMsgList(RsSyncGrpMsgList *item, void *data,
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
/* RsSyncGrpMsgList */ /* RsNxsSyncMsgItem */
ok &= setRawUInt32(data, *size, &offset, item->transactionId); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt8(data, *size, &offset, item->flag); ok &= setRawUInt8(data, *size, &offset, item->flag);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId); ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId);
ok &= item->idSign.SetTlv(data, *size, &offset);
if(offset != tlvsize){ if(offset != tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSynGrpMsgList() FAIL Size Error! " << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem() FAIL Size Error! " << std::endl;
#endif #endif
ok = false; ok = false;
} }
@ -191,7 +196,7 @@ bool RsNxsSerialiser::serialiseSynGrpMsgList(RsSyncGrpMsgList *item, void *data,
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
if (!ok) if (!ok)
{ {
std::cerr << "RsNxsSerialiser::serialiseSynGrpMsgList() NOK" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem() NOK" << std::endl;
} }
#endif #endif
@ -225,8 +230,9 @@ bool RsNxsSerialiser::serialiseNxsMsg(RsNxsMsg *item, void *data, uint32_t *size
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->msgId); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->msgId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->originalMsgId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity);
ok &= setRawUInt32(data, tlvsize, &offset, item->timeStamp); ok &= setRawUInt32(data, tlvsize, &offset, item->timeStamp);
@ -280,7 +286,7 @@ bool RsNxsSerialiser::serialiseNxsGrp(RsNxsGrp *item, void *data, uint32_t *size
offset += 8; offset += 8;
// grp id // grp id
ok &= setRawUInt32(data, *size, &offset, item->transactionId); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity);
ok &= setRawUInt32(data, tlvsize, &offset, item->grpFlag); ok &= setRawUInt32(data, tlvsize, &offset, item->grpFlag);
@ -307,19 +313,19 @@ bool RsNxsSerialiser::serialiseNxsGrp(RsNxsGrp *item, void *data, uint32_t *size
return ok; return ok;
} }
bool RsNxsSerialiser::serialiseSyncGrp(RsSyncGrp *item, void *data, uint32_t *size) bool RsNxsSerialiser::serialiseNxsSyncGrp(RsNxsSyncGrp *item, void *data, uint32_t *size)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSyncGrp()" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrp()" << std::endl;
#endif #endif
uint32_t tlvsize = sizeSyncGrp(item); uint32_t tlvsize = sizeNxsSyncGrp(item);
uint32_t offset = 0; uint32_t offset = 0;
if(*size < tlvsize){ if(*size < tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSyncGrp()" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrp()" << std::endl;
#endif #endif
return false; return false;
} }
@ -333,7 +339,7 @@ bool RsNxsSerialiser::serialiseSyncGrp(RsSyncGrp *item, void *data, uint32_t *si
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
ok &= setRawUInt32(data, *size, &offset, item->transactionId); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt8(data, *size, &offset, item->flag); ok &= setRawUInt8(data, *size, &offset, item->flag);
ok &= setRawUInt32(data, *size, &offset, item->syncAge); ok &= setRawUInt32(data, *size, &offset, item->syncAge);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash); ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash);
@ -381,11 +387,10 @@ bool RsNxsSerialiser::serialiseNxsTrans(RsNxsTransac *item, void *data, uint32_t
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
ok &= setRawUInt32(data, *size, &offset, item->transactionId); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt16(data, *size, &offset, item->transactFlag); ok &= setRawUInt16(data, *size, &offset, item->transactFlag);
ok &= setRawUInt32(data, *size, &offset, item->nItems); ok &= setRawUInt32(data, *size, &offset, item->nItems);
ok &= setRawUInt32(data, *size, &offset, item->timeout); ok &= setRawUInt32(data, *size, &offset, item->timeout);
ok &= setRawUInt32(data, *size, &offset, item->transactionId);
@ -406,18 +411,18 @@ bool RsNxsSerialiser::serialiseNxsTrans(RsNxsTransac *item, void *data, uint32_t
return ok; return ok;
} }
bool RsNxsSerialiser::serialiseSyncGrpList(RsSyncGrpList *item, void *data, uint32_t *size) bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data, uint32_t *size)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSyncGrpList()" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem()" << std::endl;
#endif #endif
uint32_t tlvsize = sizeSyncGrpList(item); uint32_t tlvsize = sizeNxsSyncGrpItem(item);
uint32_t offset = 0; uint32_t offset = 0;
if(*size < tlvsize){ if(*size < tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSyncGrpList() size do not match" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem() size do not match" << std::endl;
#endif #endif
return false; return false;
} }
@ -431,16 +436,16 @@ bool RsNxsSerialiser::serialiseSyncGrpList(RsSyncGrpList *item, void *data, uint
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
/* RsSyncGrpList */ /* RsNxsSyncGrpItem */
ok &= setRawUInt32(data, *size, &offset, item->transactionId); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt8(data, *size, &offset, item->flag); ok &= setRawUInt8(data, *size, &offset, item->flag);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= item->adminSign.SetTlv(data, *size, &offset); ok &= item->adminSign.SetTlv(data, *size, &offset);
if(offset != tlvsize){ if(offset != tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSyncGrpList( FAIL Size Error! " << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem( FAIL Size Error! " << std::endl;
#endif #endif
ok = false; ok = false;
} }
@ -448,7 +453,7 @@ bool RsNxsSerialiser::serialiseSyncGrpList(RsSyncGrpList *item, void *data, uint
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
if (!ok) if (!ok)
{ {
std::cerr << "RsNxsSerialiser::serialiseSyncGrpList() NOK" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem() NOK" << std::endl;
} }
#endif #endif
@ -456,17 +461,17 @@ bool RsNxsSerialiser::serialiseSyncGrpList(RsSyncGrpList *item, void *data, uint
} }
bool RsNxsSerialiser::serialiseSyncGrpMsg(RsSyncGrpMsg *item, void *data, uint32_t *size){ bool RsNxsSerialiser::serialiseNxsSyncMsg(RsNxsSyncMsg *item, void *data, uint32_t *size){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSyncGrpMsg()" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg()" << std::endl;
#endif #endif
uint32_t tlvsize = sizeSyncGrpMsg(item); uint32_t tlvsize = sizeNxsSyncMsg(item);
uint32_t offset = 0; uint32_t offset = 0;
if(*size < tlvsize){ if(*size < tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSyncGrpMsg()" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg()" << std::endl;
#endif #endif
return false; return false;
} }
@ -480,7 +485,7 @@ bool RsNxsSerialiser::serialiseSyncGrpMsg(RsSyncGrpMsg *item, void *data, uint32
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
ok &= setRawUInt32(data, *size, &offset, item->transactionId); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt8(data, *size, &offset, item->flag); ok &= setRawUInt8(data, *size, &offset, item->flag);
ok &= setRawUInt32(data, *size, &offset, item->syncAge); ok &= setRawUInt32(data, *size, &offset, item->syncAge);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash); ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_HASH_SHA1, item->syncHash);
@ -488,7 +493,7 @@ bool RsNxsSerialiser::serialiseSyncGrpMsg(RsSyncGrpMsg *item, void *data, uint32
if(offset != tlvsize){ if(offset != tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseSyncGrpMsg() FAIL Size Error! " << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg() FAIL Size Error! " << std::endl;
#endif #endif
ok = false; ok = false;
} }
@ -496,7 +501,7 @@ bool RsNxsSerialiser::serialiseSyncGrpMsg(RsSyncGrpMsg *item, void *data, uint32
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
if (!ok) if (!ok)
{ {
std::cerr << "RsNxsSerialiser::serialiseSyncGrpMsg( NOK" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg( NOK" << std::endl;
} }
#endif #endif
@ -626,6 +631,7 @@ RsNxsMsg* RsNxsSerialiser::deserialNxsMsg(void *data, uint32_t *size){
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->originalMsgId);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->identity); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->identity);
ok &= getRawUInt32(data, *size, &offset, &(item->timeStamp)); ok &= getRawUInt32(data, *size, &offset, &(item->timeStamp));
@ -657,10 +663,10 @@ RsNxsMsg* RsNxsSerialiser::deserialNxsMsg(void *data, uint32_t *size){
} }
RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){ RsNxsSyncGrp* RsNxsSerialiser::deserialNxsSyncGrp(void *data, uint32_t *size){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrp()" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp()" << std::endl;
#endif #endif
/* get the type and size */ /* get the type and size */
uint32_t rstype = getRsItemId(data); uint32_t rstype = getRsItemId(data);
@ -674,7 +680,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){
(RS_PKT_SUBTYPE_NXS_SYNC_GRP != getRsItemSubType(rstype))) (RS_PKT_SUBTYPE_NXS_SYNC_GRP != getRsItemSubType(rstype)))
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrp() FAIL wrong type" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() FAIL wrong type" << std::endl;
#endif #endif
return NULL; /* wrong type */ return NULL; /* wrong type */
} }
@ -682,7 +688,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){
if (*size < rssize) /* check size */ if (*size < rssize) /* check size */
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrp() FAIL wrong size" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() FAIL wrong size" << std::endl;
#endif #endif
return NULL; /* not enough data */ return NULL; /* not enough data */
} }
@ -692,7 +698,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){
bool ok = true; bool ok = true;
RsSyncGrp* item = new RsSyncGrp(getRsItemService(rstype)); RsNxsSyncGrp* item = new RsNxsSyncGrp(getRsItemService(rstype));
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
@ -704,7 +710,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){
if (offset != rssize) if (offset != rssize)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrp() FAIL size mismatch" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() FAIL size mismatch" << std::endl;
#endif #endif
/* error */ /* error */
delete item; delete item;
@ -714,7 +720,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){
if (!ok) if (!ok)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrp() NOK" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() NOK" << std::endl;
#endif #endif
delete item; delete item;
return NULL; return NULL;
@ -724,10 +730,10 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){
} }
RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){ RsNxsSyncGrpItem* RsNxsSerialiser::deserialNxsSyncGrpItem(void *data, uint32_t *size){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpList()" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem()" << std::endl;
#endif #endif
/* get the type and size */ /* get the type and size */
uint32_t rstype = getRsItemId(data); uint32_t rstype = getRsItemId(data);
@ -741,7 +747,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){
(RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM != getRsItemSubType(rstype))) (RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM != getRsItemSubType(rstype)))
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpList() FAIL wrong type" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() FAIL wrong type" << std::endl;
#endif #endif
return NULL; /* wrong type */ return NULL; /* wrong type */
} }
@ -749,7 +755,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){
if (*size < rssize) /* check size */ if (*size < rssize) /* check size */
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpList() FAIL wrong size" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() FAIL wrong size" << std::endl;
#endif #endif
return NULL; /* not enough data */ return NULL; /* not enough data */
} }
@ -759,7 +765,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){
bool ok = true; bool ok = true;
RsSyncGrpList* item = new RsSyncGrpList(SERVICE_TYPE); RsNxsSyncGrpItem* item = new RsNxsSyncGrpItem(SERVICE_TYPE);
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
@ -771,7 +777,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){
if (offset != rssize) if (offset != rssize)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpList() FAIL size mismatch" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() FAIL size mismatch" << std::endl;
#endif #endif
/* error */ /* error */
delete item; delete item;
@ -781,7 +787,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){
if (!ok) if (!ok)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpList() NOK" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() NOK" << std::endl;
#endif #endif
delete item; delete item;
return NULL; return NULL;
@ -815,7 +821,7 @@ RsNxsTransac* RsNxsSerialiser::deserialNxsTrans(void *data, uint32_t *size){
if (*size < rssize) /* check size */ if (*size < rssize) /* check size */
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList( FAIL wrong size" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem( FAIL wrong size" << std::endl;
#endif #endif
return NULL; /* not enough data */ return NULL; /* not enough data */
} }
@ -834,7 +840,6 @@ RsNxsTransac* RsNxsSerialiser::deserialNxsTrans(void *data, uint32_t *size){
ok &= getRawUInt16(data, *size, &offset, &(item->transactFlag)); ok &= getRawUInt16(data, *size, &offset, &(item->transactFlag));
ok &= getRawUInt32(data, *size, &offset, &(item->nItems)); ok &= getRawUInt32(data, *size, &offset, &(item->nItems));
ok &= getRawUInt32(data, *size, &offset, &(item->timeout)); ok &= getRawUInt32(data, *size, &offset, &(item->timeout));
ok &= getRawUInt32(data, *size, &offset, &(item->transactionId));
if (offset != rssize) if (offset != rssize)
{ {
@ -860,10 +865,10 @@ RsNxsTransac* RsNxsSerialiser::deserialNxsTrans(void *data, uint32_t *size){
} }
RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t *size){ RsNxsSyncMsgItem* RsNxsSerialiser::deserialNxsSyncMsgItem(void *data, uint32_t *size){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList()" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem()" << std::endl;
#endif #endif
/* get the type and size */ /* get the type and size */
uint32_t rstype = getRsItemId(data); uint32_t rstype = getRsItemId(data);
@ -874,10 +879,10 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t *
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(SERVICE_TYPE != getRsItemService(rstype)) || (SERVICE_TYPE != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_SYNC_MSG_LIST != getRsItemSubType(rstype))) (RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM != getRsItemSubType(rstype)))
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList() FAIL wrong type" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem() FAIL wrong type" << std::endl;
#endif #endif
return NULL; /* wrong type */ return NULL; /* wrong type */
} }
@ -885,7 +890,7 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t *
if (*size < rssize) /* check size */ if (*size < rssize) /* check size */
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList( FAIL wrong size" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem( FAIL wrong size" << std::endl;
#endif #endif
return NULL; /* not enough data */ return NULL; /* not enough data */
} }
@ -895,7 +900,7 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t *
bool ok = true; bool ok = true;
RsSyncGrpMsgList* item = new RsSyncGrpMsgList(getRsItemService(rstype)); RsNxsSyncMsgItem* item = new RsNxsSyncMsgItem(getRsItemService(rstype));
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
@ -903,12 +908,11 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t *
ok &= getRawUInt8(data, *size, &offset, &(item->flag)); ok &= getRawUInt8(data, *size, &offset, &(item->flag));
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId);
ok &= item->idSign.GetTlv(data, *size, &offset);
if (offset != rssize) if (offset != rssize)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList() FAIL size mismatch" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem() FAIL size mismatch" << std::endl;
#endif #endif
/* error */ /* error */
delete item; delete item;
@ -918,7 +922,7 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t *
if (!ok) if (!ok)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList() NOK" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem() NOK" << std::endl;
#endif #endif
delete item; delete item;
return NULL; return NULL;
@ -928,12 +932,12 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t *
} }
RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size) RsNxsSyncMsg* RsNxsSerialiser::deserialNxsSyncMsg(void *data, uint32_t *size)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrp()" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp()" << std::endl;
#endif #endif
/* get the type and size */ /* get the type and size */
uint32_t rstype = getRsItemId(data); uint32_t rstype = getRsItemId(data);
@ -944,10 +948,10 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size)
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(SERVICE_TYPE != getRsItemService(rstype)) || (SERVICE_TYPE != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_SYNC_MSG != getRsItemSubType(rstype))) (RS_PKT_SUBTYPE_NXS_SYNC_MSG != getRsItemSubType(rstype)))
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsg() FAIL wrong type" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() FAIL wrong type" << std::endl;
#endif #endif
return NULL; /* wrong type */ return NULL; /* wrong type */
} }
@ -955,7 +959,7 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size)
if (*size < rssize) /* check size */ if (*size < rssize) /* check size */
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsg() FAIL wrong size" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() FAIL wrong size" << std::endl;
#endif #endif
return NULL; /* not enough data */ return NULL; /* not enough data */
} }
@ -965,7 +969,7 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size)
bool ok = true; bool ok = true;
RsSyncGrpMsg* item = new RsSyncGrpMsg(getRsItemService(rstype)); RsNxsSyncMsg* item = new RsNxsSyncMsg(getRsItemService(rstype));
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
@ -979,7 +983,7 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size)
if (offset != rssize) if (offset != rssize)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsg() FAIL size mismatch" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() FAIL size mismatch" << std::endl;
#endif #endif
/* error */ /* error */
delete item; delete item;
@ -989,7 +993,7 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size)
if (!ok) if (!ok)
{ {
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::deserialSyncGrpMsg() NOK" << std::endl; std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() NOK" << std::endl;
#endif #endif
delete item; delete item;
return NULL; return NULL;
@ -1013,9 +1017,11 @@ uint32_t RsNxsSerialiser::sizeNxsMsg(RsNxsMsg *item)
uint32_t s = 8; //header size uint32_t s = 8; //header size
s += 4; // transaction number
s += GetTlvStringSize(item->grpId); s += GetTlvStringSize(item->grpId);
s += GetTlvStringSize(item->msgId); s += GetTlvStringSize(item->msgId);
s += GetTlvStringSize(item->identity); s += GetTlvStringSize(item->identity);
s += GetTlvStringSize(item->originalMsgId);
s += 4; // msgFlag s += 4; // msgFlag
s += 4; // timeStamp s += 4; // timeStamp
s += item->publishSign.TlvSize(); s += item->publishSign.TlvSize();
@ -1043,7 +1049,7 @@ uint32_t RsNxsSerialiser::sizeNxsGrp(RsNxsGrp *item)
} }
uint32_t RsNxsSerialiser::sizeSyncGrp(RsSyncGrp *item) uint32_t RsNxsSerialiser::sizeNxsSyncGrp(RsNxsSyncGrp *item)
{ {
uint32_t s = 8; // header size uint32_t s = 8; // header size
@ -1056,7 +1062,7 @@ uint32_t RsNxsSerialiser::sizeSyncGrp(RsSyncGrp *item)
} }
uint32_t RsNxsSerialiser::sizeSyncGrpList(RsSyncGrpList *item) uint32_t RsNxsSerialiser::sizeNxsSyncGrpItem(RsNxsSyncGrpItem *item)
{ {
uint32_t s = 8; // header size uint32_t s = 8; // header size
@ -1069,7 +1075,7 @@ uint32_t RsNxsSerialiser::sizeSyncGrpList(RsSyncGrpList *item)
} }
uint32_t RsNxsSerialiser::sizeSyncGrpMsg(RsSyncGrpMsg *item) uint32_t RsNxsSerialiser::sizeNxsSyncMsg(RsNxsSyncMsg *item)
{ {
uint32_t s = 8; uint32_t s = 8;
@ -1084,7 +1090,7 @@ uint32_t RsNxsSerialiser::sizeSyncGrpMsg(RsSyncGrpMsg *item)
} }
uint32_t RsNxsSerialiser::sizeSyncGrpMsgList(RsSyncGrpMsgList *item) uint32_t RsNxsSerialiser::sizeNxsSyncMsgItem(RsNxsSyncMsgItem *item)
{ {
uint32_t s = 8; // header size uint32_t s = 8; // header size
@ -1092,7 +1098,6 @@ uint32_t RsNxsSerialiser::sizeSyncGrpMsgList(RsSyncGrpMsgList *item)
s += 1; // flag s += 1; // flag
s += GetTlvStringSize(item->grpId); s += GetTlvStringSize(item->grpId);
s += GetTlvStringSize(item->msgId); s += GetTlvStringSize(item->msgId);
s += item->idSign.TlvSize();
return s; return s;
} }
@ -1105,7 +1110,6 @@ uint32_t RsNxsSerialiser::sizeNxsTrans(RsNxsTransac *item){
s += 2; // flag s += 2; // flag
s += 4; // nMsgs s += 4; // nMsgs
s += 4; // timeout s += 4; // timeout
s += 4; // transaction id
return s; return s;
} }
@ -1128,6 +1132,7 @@ void RsNxsMsg::clear()
publishSign.TlvClear(); publishSign.TlvClear();
idSign.TlvClear(); idSign.TlvClear();
identity.clear(); identity.clear();
originalMsgId.clear();
} }
void RsNxsGrp::clear() void RsNxsGrp::clear()
@ -1142,14 +1147,14 @@ void RsNxsGrp::clear()
idSign.TlvClear(); idSign.TlvClear();
} }
void RsSyncGrp::clear() void RsNxsSyncGrp::clear()
{ {
flag = 0; flag = 0;
syncAge = 0; syncAge = 0;
syncHash.clear(); syncHash.clear();
} }
void RsSyncGrpMsg::clear() void RsNxsSyncMsg::clear()
{ {
grpId.clear(); grpId.clear();
flag = 0; flag = 0;
@ -1157,18 +1162,17 @@ void RsSyncGrpMsg::clear()
syncHash.clear(); syncHash.clear();
} }
void RsSyncGrpList::clear() void RsNxsSyncGrpItem::clear()
{ {
flag = 0; flag = 0;
adminSign.TlvClear(); adminSign.TlvClear();
grpId.clear(); grpId.clear();
} }
void RsSyncGrpMsgList::clear() void RsNxsSyncMsgItem::clear()
{ {
flag = 0; flag = 0;
msgId.clear(); msgId.clear();
idSign.TlvClear();
grpId.clear(); grpId.clear();
} }
@ -1176,13 +1180,13 @@ void RsNxsTransac::clear(){
transactFlag = 0; transactFlag = 0;
nItems = 0; nItems = 0;
timeout = 0; timeout = 0;
transactionId = 0; transactionNumber = 0;
} }
std::ostream& RsSyncGrp::print(std::ostream &out, uint16_t indent) std::ostream& RsNxsSyncGrp::print(std::ostream &out, uint16_t indent)
{ {
printRsItemBase(out, "RsSyncGrp", indent); printRsItemBase(out, "RsNxsSyncGrp", indent);
uint16_t int_Indent = indent + 2; uint16_t int_Indent = indent + 2;
printIndent(out , int_Indent); printIndent(out , int_Indent);
@ -1193,7 +1197,7 @@ std::ostream& RsSyncGrp::print(std::ostream &out, uint16_t indent)
out << "flag" << flag << std::endl; out << "flag" << flag << std::endl;
printRsItemEnd(out ,"RsSyncGrp", indent); printRsItemEnd(out ,"RsNxsSyncGrp", indent);
return out; return out;
} }
@ -1212,9 +1216,9 @@ std::ostream& RsNxsExtended::print(std::ostream &out, uint16_t indent){
return out; return out;
} }
std::ostream& RsSyncGrpMsg::print(std::ostream &out, uint16_t indent) std::ostream& RsNxsSyncMsg::print(std::ostream &out, uint16_t indent)
{ {
printRsItemBase(out, "RsSyncGrpMsg", indent); printRsItemBase(out, "RsNxsSyncMsg", indent);
uint16_t int_Indent = indent + 2; uint16_t int_Indent = indent + 2;
printIndent(out , int_Indent); printIndent(out , int_Indent);
@ -1226,13 +1230,13 @@ std::ostream& RsSyncGrpMsg::print(std::ostream &out, uint16_t indent)
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "flag: " << flag << std::endl; out << "flag: " << flag << std::endl;
printRsItemEnd(out, "RsSyncGrpMsg", indent); printRsItemEnd(out, "RsNxsSyncMsg", indent);
return out; return out;
} }
std::ostream& RsSyncGrpList::print(std::ostream &out, uint16_t indent) std::ostream& RsNxsSyncGrpItem::print(std::ostream &out, uint16_t indent)
{ {
printRsItemBase(out, "RsSyncGrpList", indent); printRsItemBase(out, "RsNxsSyncGrpItem", indent);
uint16_t int_Indent = indent + 2; uint16_t int_Indent = indent + 2;
printIndent(out , int_Indent); printIndent(out , int_Indent);
@ -1243,15 +1247,15 @@ std::ostream& RsSyncGrpList::print(std::ostream &out, uint16_t indent)
adminSign.print(out, indent); adminSign.print(out, indent);
printIndent(out , int_Indent); printIndent(out , int_Indent);
printRsItemEnd(out , "RsSyncGrpList", indent); printRsItemEnd(out , "RsNxsSyncGrpItem", indent);
return out; return out;
} }
std::ostream& RsSyncGrpMsgList::print(std::ostream &out, uint16_t indent) std::ostream& RsNxsSyncMsgItem::print(std::ostream &out, uint16_t indent)
{ {
printRsItemBase(out, "RsSyncGrpMsgList", indent); printRsItemBase(out, "RsNxsSyncMsgItem", indent);
uint16_t int_Indent = indent + 2; uint16_t int_Indent = indent + 2;
printIndent(out , int_Indent); printIndent(out , int_Indent);
@ -1261,10 +1265,8 @@ std::ostream& RsSyncGrpMsgList::print(std::ostream &out, uint16_t indent)
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "msgId: " << msgId << std::endl; out << "msgId: " << msgId << std::endl;
printIndent(out , int_Indent); printIndent(out , int_Indent);
idSign.print(out, indent);
printIndent(out , int_Indent);
printRsItemEnd(out ,"RsSyncGrpMsgList", indent); printRsItemEnd(out ,"RsNxsSyncMsgItem", indent);
return out; return out;
} }
@ -1327,7 +1329,7 @@ std::ostream& RsNxsTransac::print(std::ostream &out, uint16_t indent){
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "timeout: " << timeout << std::endl; out << "timeout: " << timeout << std::endl;
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "transactionId: " << transactionId << std::endl; out << "transactionNumber: " << transactionNumber << std::endl;
printIndent(out , int_Indent); printIndent(out , int_Indent);
printRsItemEnd(out ,"RsNxsTransac", indent); printRsItemEnd(out ,"RsNxsTransac", indent);

62
libretroshare/src/serialiser/rsnxsitems.h
View File

@ -88,7 +88,7 @@ public:
static const uint8_t FLAG_USE_SYNC_HASH; static const uint8_t FLAG_USE_SYNC_HASH;
static const uint8_t FLAG_ONLY_CURRENT; // only send most current version of grps / ignores sync hash static const uint8_t FLAG_ONLY_CURRENT; // only send most current version of grps / ignores sync hash
RsNxsSyncGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP) { return;} RsNxsSyncGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP) { clear(); return;}
virtual void clear(); virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent); virtual std::ostream &print(std::ostream &out, uint16_t indent);
@ -111,6 +111,9 @@ class RsNxsTransac : public RsNxsItem {
public: public:
static const uint16_t FLAG_TRANS_MASK = 0xf;
static const uint16_t FLAG_TYPE_MASK = 0xff;
/** transaction **/ /** transaction **/
static const uint16_t FLAG_BEGIN_P1; static const uint16_t FLAG_BEGIN_P1;
static const uint16_t FLAG_BEGIN_P2; static const uint16_t FLAG_BEGIN_P2;
@ -129,7 +132,7 @@ public:
static const uint16_t FLAG_TYPE_GRPS; static const uint16_t FLAG_TYPE_GRPS;
static const uint16_t FLAG_TYPE_MSGS; static const uint16_t FLAG_TYPE_MSGS;
RsNxsTransac(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_TRANS) { return; } RsNxsTransac(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_TRANS) { clear(); return; }
virtual ~RsNxsTransac() { return ; } virtual ~RsNxsTransac() { return ; }
virtual void clear(); virtual void clear();
@ -138,7 +141,6 @@ public:
uint16_t transactFlag; uint16_t transactFlag;
uint32_t nItems; uint32_t nItems;
uint32_t timeout; uint32_t timeout;
uint32_t transactionId;
}; };
/*! /*!
@ -154,8 +156,8 @@ public:
static const uint8_t FLAG_RESPONSE; static const uint8_t FLAG_RESPONSE;
static const uint8_t FLAG_USE_SYNC_HASH; static const uint8_t FLAG_USE_SYNC_HASH;
RsNxsSyncGrpItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM) { return ; } RsNxsSyncGrpItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM) { clear(); return ; }
virtual ~RsNxsSyncGrpList() { return; } virtual ~RsNxsSyncGrpItem() { return; }
virtual void clear(); virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent); virtual std::ostream &print(std::ostream &out, uint16_t indent);
@ -179,7 +181,7 @@ class RsNxsGrp : public RsNxsItem
public: public:
RsNxsGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP), grp(servtype) { return; } RsNxsGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP), grp(servtype) { clear(); return; }
virtual void clear(); virtual void clear();
@ -206,7 +208,7 @@ public:
static const uint8_t FLAG_USE_SYNC_HASH; static const uint8_t FLAG_USE_SYNC_HASH;
RsNxsSyncMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_MSG) {return; } RsNxsSyncMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_MSG) { clear(); return; }
virtual void clear(); virtual void clear();
@ -229,7 +231,7 @@ public:
static const uint8_t FLAG_REQUEST; static const uint8_t FLAG_REQUEST;
static const uint8_t FLAG_RESPONSE; static const uint8_t FLAG_RESPONSE;
static const uint8_t FLAG_USE_SYNC_HASH; static const uint8_t FLAG_USE_SYNC_HASH;
RsNxsSyncMsgItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM) { return; } RsNxsSyncMsgItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM) { clear(); return; }
virtual void clear(); virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent); virtual std::ostream &print(std::ostream &out, uint16_t indent);
@ -249,7 +251,7 @@ class RsNxsMsg : public RsNxsItem
{ {
public: public:
RsNxsMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_MSG), msg(servtype) { return; } RsNxsMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_MSG), msg(servtype) { clear(); return; }
virtual void clear(); virtual void clear();
@ -397,11 +399,11 @@ private:
virtual bool serialiseNxsSyncGrp(RsNxsSyncGrp *item, void *data, uint32_t *size); virtual bool serialiseNxsSyncGrp(RsNxsSyncGrp *item, void *data, uint32_t *size);
virtual RsNxsSyncGrp* deserialNxsSyncGrp(void *data, uint32_t *size); virtual RsNxsSyncGrp* deserialNxsSyncGrp(void *data, uint32_t *size);
/* for RS_PKT_SUBTYPE_SYNC_GRP_LIST */ /* for RS_PKT_SUBTYPE_SYNC_GRP_ITEM */
virtual uint32_t sizeSyncGrpList(RsNxsSyncGrpItem* item); virtual uint32_t sizeNxsSyncGrpItem(RsNxsSyncGrpItem* item);
virtual bool serialiseNxsSyncGrpList(RsNxsSyncGrpItem *item, void *data, uint32_t *size); virtual bool serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data, uint32_t *size);
virtual RsNxsSyncGrpItem* deserialNxsSyncGrpList(void *data, uint32_t *size); virtual RsNxsSyncGrpItem* deserialNxsSyncGrpItem(void *data, uint32_t *size);
/* for RS_PKT_SUBTYPE_NXS_GRP */ /* for RS_PKT_SUBTYPE_NXS_GRP */
@ -411,15 +413,15 @@ private:
/* for RS_PKT_SUBTYPE_SYNC_MSG */ /* for RS_PKT_SUBTYPE_SYNC_MSG */
virtual uint32_t sizeSyncGrpMsg(RsSyncGrpMsg* item); virtual uint32_t sizeNxsSyncMsg(RsNxsSyncMsg* item);
virtual bool serialiseSyncGrpMsg(RsSyncGrpMsg *item, void *data, uint32_t *size); virtual bool serialiseNxsSyncMsg(RsNxsSyncMsg *item, void *data, uint32_t *size);
virtual RsSyncGrpMsg* deserialSyncGrpMsg(void *data, uint32_t *size); virtual RsNxsSyncMsg* deserialNxsSyncMsg(void *data, uint32_t *size);
/* RS_PKT_SUBTYPE_SYNC_MSG_LIST */ /* RS_PKT_SUBTYPE_SYNC_MSG_ITEM */
virtual uint32_t sizeSyncGrpMsgList(RsSyncGrpMsgList* item); virtual uint32_t sizeNxsSyncMsgItem(RsNxsSyncMsgItem* item);
virtual bool serialiseSynGrpMsgList(RsSyncGrpMsgList* item, void *data, uint32_t* size); virtual bool serialiseNxsSynMsgItem(RsNxsSyncMsgItem* item, void *data, uint32_t* size);
virtual RsSyncGrpMsgList* deserialSyncGrpMsgList(void *data, uint32_t *size); virtual RsNxsSyncMsgItem* deserialNxsSyncMsgItem(void *data, uint32_t *size);
/* RS_PKT_SUBTYPE_NXS_MSG */ /* RS_PKT_SUBTYPE_NXS_MSG */
@ -443,4 +445,24 @@ private:
}; };
class RsGxsMsgId {
public:
std::string grpId;
std::string msgId;
RsTlvKeySignature idSign;
};
class RsGxsGrpId {
public:
std::string grpId;
RsTlvKeySignature adminSign;
};
#endif // RSNXSITEMS_H #endif // RSNXSITEMS_H

44
libretroshare/src/tests/gxs/rsdataservice_test.cc
View File

@ -21,8 +21,6 @@ int main()
test_messageStoresAndRetrieve(); REPORT("test_messageStoresAndRetrieve"); test_messageStoresAndRetrieve(); REPORT("test_messageStoresAndRetrieve");
test_messageVersionRetrieve(); REPORT("test_messageVersionRetrieve");
test_groupVersionRetrieve(); REPORT("test_groupVersionRetrieve"); test_groupVersionRetrieve(); REPORT("test_groupVersionRetrieve");
FINALREPORT("RsDataService Tests"); FINALREPORT("RsDataService Tests");
@ -138,48 +136,6 @@ void test_messageStoresAndRetrieve(){
tearDown(); tearDown();
} }
void test_messageVersionRetrieve(){
setUp();
// place two messages in store and attempt to retrieve them
std::set<RsNxsMsg*> s;
RsNxsMsg* msg1 = new RsNxsMsg(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);;
RsNxsMsg* msg2 = new RsNxsMsg(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);;
RsNxsMsg* msg3 = new RsNxsMsg(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);;
std::string grpId;
randString(SHORT_STR, grpId);
msg1->grpId = grpId;
msg2->grpId = grpId;
msg3->grpId = grpId;
init_item(msg1);
init_item(msg2);
init_item(msg3);
s.insert(msg1); s.insert(msg2); s.insert(msg3);
dStore->storeMessage(s);
RsGxsMsgId msgId;
msgId.grpId = msg2->grpId;
msgId.idSign = msg2->idSign;
msgId.msgId = msg2->msgId;
RsNxsMsg* msg2_r = dStore->retrieveMsgVersion(msgId);
CHECK(msg2_r != NULL);
if(msg2_r)
CHECK(*msg2 == *msg2_r);
delete msg1;
delete msg2;
delete msg3;
delete msg2_r;
std::string msgFile = grpId + "-msgs";
remove(msgFile.c_str());
tearDown();
}
void test_groupVersionRetrieve(){ void test_groupVersionRetrieve(){

49
libretroshare/src/tests/serialiser/rsnxsitems_test.cc
View File

@ -15,6 +15,7 @@ RsSerialType* init_item(RsNxsGrp& nxg)
randString(SHORT_STR, nxg.identity); randString(SHORT_STR, nxg.identity);
randString(SHORT_STR, nxg.grpId); randString(SHORT_STR, nxg.grpId);
nxg.timeStamp = rand()%23; nxg.timeStamp = rand()%23;
nxg.transactionNumber = rand()%23;
nxg.grpFlag = rand()%242; nxg.grpFlag = rand()%242;
init_item(nxg.grp); init_item(nxg.grp);
@ -46,38 +47,41 @@ RsSerialType* init_item(RsNxsMsg& nxm)
init_item(nxm.msg); init_item(nxm.msg);
nxm.msgFlag = rand()%4252; nxm.msgFlag = rand()%4252;
nxm.timeStamp = rand()%246; nxm.timeStamp = rand()%246;
nxm.transactionNumber = rand()%23;
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
} }
RsSerialType* init_item(RsSyncGrp& rsg) RsSerialType* init_item(RsNxsSyncGrp& rsg)
{ {
rsg.clear(); rsg.clear();
rsg.flag = RsSyncGrp::FLAG_USE_SYNC_HASH; rsg.flag = RsNxsSyncGrp::FLAG_USE_SYNC_HASH;
rsg.syncAge = rand()%2423; rsg.syncAge = rand()%2423;
randString(3124,rsg.syncHash); randString(3124,rsg.syncHash);
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
} }
RsSerialType* init_item(RsSyncGrpMsg& rsgm) RsSerialType* init_item(RsNxsSyncMsg& rsgm)
{ {
rsgm.clear(); rsgm.clear();
rsgm.flag = RsSyncGrpMsg::FLAG_USE_SYNC_HASH; rsgm.flag = RsNxsSyncMsg::FLAG_USE_SYNC_HASH;
rsgm.syncAge = rand()%24232; rsgm.syncAge = rand()%24232;
rsgm.transactionNumber = rand()%23;
randString(SHORT_STR, rsgm.grpId); randString(SHORT_STR, rsgm.grpId);
randString(SHORT_STR, rsgm.syncHash); randString(SHORT_STR, rsgm.syncHash);
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
} }
RsSerialType* init_item(RsSyncGrpList& rsgl) RsSerialType* init_item(RsNxsSyncGrpItem& rsgl)
{ {
rsgl.clear(); rsgl.clear();
rsgl.flag = RsSyncGrpList::FLAG_RESPONSE; rsgl.flag = RsNxsSyncGrpItem::FLAG_RESPONSE;
rsgl.transactionNumber = rand()%23;
randString(SHORT_STR, rsgl.grpId); randString(SHORT_STR, rsgl.grpId);
init_item(rsgl.adminSign); init_item(rsgl.adminSign);
@ -85,14 +89,14 @@ RsSerialType* init_item(RsSyncGrpList& rsgl)
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
} }
RsSerialType* init_item(RsSyncGrpMsgList& rsgml) RsSerialType* init_item(RsNxsSyncMsgItem& rsgml)
{ {
rsgml.clear(); rsgml.clear();
rsgml.flag = RsSyncGrpList::FLAG_RESPONSE; rsgml.flag = RsNxsSyncGrpItem::FLAG_RESPONSE;
rsgml.transactionNumber = rand()%23;
randString(SHORT_STR, rsgml.grpId); randString(SHORT_STR, rsgml.grpId);
randString(SHORT_STR, rsgml.msgId); randString(SHORT_STR, rsgml.msgId);
init_item(rsgml.idSign);
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
} }
@ -104,7 +108,7 @@ RsSerialType* init_item(RsNxsTransac& rstx){
rstx.timeout = rand()%14141; rstx.timeout = rand()%14141;
rstx.transactFlag = rand()%2424; rstx.transactFlag = rand()%2424;
rstx.nItems = rand()%33132; rstx.nItems = rand()%33132;
rstx.transactionId = rand()%242112; rstx.transactionNumber = rand()%242112;
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
} }
@ -119,6 +123,7 @@ bool operator==(const RsNxsGrp& l, const RsNxsGrp& r){
if(l.grpId != r.grpId) return false; if(l.grpId != r.grpId) return false;
if(l.keys.groupId != r.keys.groupId) return false; if(l.keys.groupId != r.keys.groupId) return false;
if(!(l.grp == r.grp) ) return false; if(!(l.grp == r.grp) ) return false;
if(l.transactionNumber != r.transactionNumber) return false;
std::map<std::string, RsTlvSecurityKey>::const_iterator mit = std::map<std::string, RsTlvSecurityKey>::const_iterator mit =
l.keys.keys.begin(), mit_end = l.keys.keys.end(); l.keys.keys.begin(), mit_end = l.keys.keys.end();
@ -143,46 +148,50 @@ bool operator==(const RsNxsMsg& l, const RsNxsMsg& r){
if(! (l.msg == r.msg) ) return false; if(! (l.msg == r.msg) ) return false;
if(! (l.publishSign == r.publishSign) ) return false; if(! (l.publishSign == r.publishSign) ) return false;
if(! (l.idSign == r.idSign) ) return false; if(! (l.idSign == r.idSign) ) return false;
if(l.transactionNumber != r.transactionNumber) return false;
return true; return true;
} }
bool operator==(const RsSyncGrp& l, const RsSyncGrp& r) bool operator==(const RsNxsSyncGrp& l, const RsNxsSyncGrp& r)
{ {
if(l.syncHash != r.syncHash) return false; if(l.syncHash != r.syncHash) return false;
if(l.flag != r.flag) return false; if(l.flag != r.flag) return false;
if(l.syncAge != r.syncAge) return false; if(l.syncAge != r.syncAge) return false;
if(l.transactionNumber != r.transactionNumber) return false;
return true; return true;
} }
bool operator==(const RsSyncGrpMsg& l, const RsSyncGrpMsg& r) bool operator==(const RsNxsSyncMsg& l, const RsNxsSyncMsg& r)
{ {
if(l.flag != r.flag) return false; if(l.flag != r.flag) return false;
if(l.syncAge != r.syncAge) return false; if(l.syncAge != r.syncAge) return false;
if(l.syncHash != r.syncHash) return false; if(l.syncHash != r.syncHash) return false;
if(l.grpId != r.grpId) return false; if(l.grpId != r.grpId) return false;
if(l.transactionNumber != r.transactionNumber) return false;
return true; return true;
} }
bool operator==(const RsSyncGrpList& l, const RsSyncGrpList& r) bool operator==(const RsNxsSyncGrpItem& l, const RsNxsSyncGrpItem& r)
{ {
if(l.flag != r.flag) return false; if(l.flag != r.flag) return false;
if(! (l.adminSign == r.adminSign) ) return false; if(! (l.adminSign == r.adminSign) ) return false;
if(l.grpId != r.grpId) return false; if(l.grpId != r.grpId) return false;
if(l.transactionNumber != r.transactionNumber) return false;
return true; return true;
} }
bool operator==(const RsSyncGrpMsgList& l, const RsSyncGrpMsgList& r) bool operator==(const RsNxsSyncMsgItem& l, const RsNxsSyncMsgItem& r)
{ {
if(l.flag != r.flag) return false; if(l.flag != r.flag) return false;
if(l.grpId != r.grpId) return false; if(l.grpId != r.grpId) return false;
if(l.msgId != r.msgId) return false; if(l.msgId != r.msgId) return false;
if(! (l.idSign == r.idSign) ) return false; if(l.transactionNumber != r.transactionNumber) return false;
return true; return true;
} }
@ -190,7 +199,7 @@ bool operator==(const RsSyncGrpMsgList& l, const RsSyncGrpMsgList& r)
bool operator==(const RsNxsTransac& l, const RsNxsTransac& r){ bool operator==(const RsNxsTransac& l, const RsNxsTransac& r){
if(l.transactFlag != r.transactFlag) return false; if(l.transactFlag != r.transactFlag) return false;
if(l.transactionId != r.transactionId) return false; if(l.transactionNumber != r.transactionNumber) return false;
if(l.timeout != r.timeout) return false; if(l.timeout != r.timeout) return false;
if(l.nItems != r.nItems) return false; if(l.nItems != r.nItems) return false;
@ -204,10 +213,10 @@ int main()
test_RsItem<RsNxsGrp>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsGrpResp"); test_RsItem<RsNxsGrp>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsGrpResp");
test_RsItem<RsNxsMsg>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsGrpMsgResp"); test_RsItem<RsNxsMsg>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsGrpMsgResp");
test_RsItem<RsSyncGrp>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrp"); test_RsItem<RsNxsSyncGrp>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsSyncGrp");
test_RsItem<RsSyncGrpMsg>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpMsg"); test_RsItem<RsNxsSyncMsg>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsSyncMsg");
test_RsItem<RsSyncGrpList>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpList"); test_RsItem<RsNxsSyncGrpItem>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsSyncGrpItem");
test_RsItem<RsSyncGrpMsgList>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpMsgList"); test_RsItem<RsNxsSyncMsgItem>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsSyncMsgItem");
test_RsItem<RsNxsTransac>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsTransac"); test_RsItem<RsNxsTransac>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsTransac");
FINALREPORT("RsNxsItem Tests"); FINALREPORT("RsNxsItem Tests");

16
libretroshare/src/tests/serialiser/rsnxsitems_test.h
View File

@ -6,18 +6,18 @@
RsSerialType* init_item(RsNxsGrp&); RsSerialType* init_item(RsNxsGrp&);
RsSerialType* init_item(RsNxsMsg&); RsSerialType* init_item(RsNxsMsg&);
RsSerialType* init_item(RsSyncGrp&); RsSerialType* init_item(RsNxsSyncGrp&);
RsSerialType* init_item(RsSyncGrpMsg&); RsSerialType* init_item(RsNxsSyncMsg&);
RsSerialType* init_item(RsSyncGrpList&); RsSerialType* init_item(RsNxsSyncGrpItem&);
RsSerialType* init_item(RsSyncGrpMsgList&); RsSerialType* init_item(RsNxsSyncMsgItem&);
RsSerialType* init_item(RsNxsTransac& ); RsSerialType* init_item(RsNxsTransac& );
bool operator==(const RsNxsGrp&, const RsNxsGrp&); bool operator==(const RsNxsGrp&, const RsNxsGrp&);
bool operator==(const RsNxsMsg&, const RsNxsMsg&); bool operator==(const RsNxsMsg&, const RsNxsMsg&);
bool operator==(const RsSyncGrp&, const RsSyncGrp&); bool operator==(const RsNxsSyncGrp&, const RsNxsSyncGrp&);
bool operator==(const RsSyncGrpMsg&, const RsSyncGrpMsg&); bool operator==(const RsNxsSyncMsg&, const RsNxsSyncMsg&);
bool operator==(const RsSyncGrpList&, const RsSyncGrpList&); bool operator==(const RsNxsSyncGrpItem&, const RsNxsSyncGrpItem&);
bool operator==(const RsSyncGrpMsgList&, const RsSyncGrpMsgList&); bool operator==(const RsNxsSyncMsgItem&, const RsNxsSyncMsgItem&);
bool operator==(const RsNxsTransac&, const RsNxsTransac& ); bool operator==(const RsNxsTransac&, const RsNxsTransac& );

3
libretroshare/src/tests/serialiser/support.h
View File

@ -165,7 +165,7 @@ template<class T> int test_RsItem(uint16_t servtype)
/* initialise */ /* initialise */
T rsfi(servtype) ; T rsfi(servtype) ;
RsSerialType *rsfis = init_item(rsfi) ; RsSerialType *rsfis = init_item(rsfi) ; // deleted on destruction of srl
/* attempt to serialise it before we add it to the serialiser */ /* attempt to serialise it before we add it to the serialiser */
@ -216,7 +216,6 @@ template<class T> int test_RsItem(uint16_t servtype)
// displayRawPacket(std::cerr, (void *) buffer, 16 * 8 + sersize2); // displayRawPacket(std::cerr, (void *) buffer, 16 * 8 + sersize2);
delete[] buffer ; delete[] buffer ;
//delete rsfis;
return 1; return 1;
} }