From 441a51757f6f26202ed6a5afc1cd5bcd7e1fb9e6 Mon Sep 17 00:00:00 2001 From: chrisparker126 Date: Mon, 11 Jun 2012 21:56:23 +0000 Subject: [PATCH] returned src to compilable stage 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 --- libretroshare/src/gxs/rsdataservice.cc | 65 +-- libretroshare/src/gxs/rsdataservice.h | 14 - libretroshare/src/gxs/rsgds.h | 24 +- libretroshare/src/gxs/rsgxs.h | 29 - libretroshare/src/gxs/rsgxsnetservice.cc | 551 +++++++++++++++++- libretroshare/src/gxs/rsgxsnetservice.h | 148 +++-- libretroshare/src/gxs/rsnxs.h | 10 +- libretroshare/src/libretroshare.pro | 6 +- libretroshare/src/serialiser/rsnxsitems.cc | 256 ++++---- libretroshare/src/serialiser/rsnxsitems.h | 62 +- .../src/tests/gxs/rsdataservice_test.cc | 44 -- .../src/tests/serialiser/rsnxsitems_test.cc | 49 +- .../src/tests/serialiser/rsnxsitems_test.h | 16 +- libretroshare/src/tests/serialiser/support.h | 3 +- 14 files changed, 886 insertions(+), 391 deletions(-) diff --git a/libretroshare/src/gxs/rsdataservice.cc b/libretroshare/src/gxs/rsdataservice.cc index 765d70a8a..04a3a0c8c 100644 --- a/libretroshare/src/gxs/rsdataservice.cc +++ b/libretroshare/src/gxs/rsdataservice.cc @@ -25,6 +25,7 @@ // msg table columns #define KEY_PUBLISH_SIGN std::string("publishSign") #define KEY_MSG_ID std::string("msgId") +#define KEY_ORIG_MSG_ID std::string("origMsgId") // grp col numbers @@ -35,6 +36,7 @@ // msg col numbers #define COL_PUBLISH_SIGN 1 #define COL_MSG_ID 9 +#define COL_ORIG_MSG_ID 10 // generic col numbers #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_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_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_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 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_IDENTITY_SIGN + " BLOB," + KEY_NXS_FILE + " TEXT,"+ KEY_NXS_FILE_OFFSET + " INT," + KEY_NXS_FILE_LEN+ " INT);"); @@ -412,34 +414,6 @@ int RsDataService::retrieveMsgs(const std::string &grpId, std::map& 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 &grp, bool cache){ std::string selection = KEY_GRP_ID + "='" + grpId + "'"; @@ -496,37 +470,6 @@ RsNxsGrp* RsDataService::retrieveGrpVersion(const RsGxsGrpId &grpId){ return grp; } -RsNxsMsg* RsDataService::retrieveMsgVersion(const RsGxsMsgId &msgId){ - - std::set msgs; - retrieveMsgVersions(msgId.grpId, msgId.msgId, msgs, false); - RsNxsMsg* msg = NULL; - - if(!msgs.empty()){ - - std::set::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(){ diff --git a/libretroshare/src/gxs/rsdataservice.h b/libretroshare/src/gxs/rsdataservice.h index 93d9ad3ee..2a449cde3 100644 --- a/libretroshare/src/gxs/rsdataservice.h +++ b/libretroshare/src/gxs/rsdataservice.h @@ -38,20 +38,6 @@ public: */ int retrieveGrpVersions(const std::string &grpId, std::set &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& 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 * @return NULL if group does not exist or pointer to grp if found diff --git a/libretroshare/src/gxs/rsgds.h b/libretroshare/src/gxs/rsgds.h index 2ed195fa1..976812842 100644 --- a/libretroshare/src/gxs/rsgds.h +++ b/libretroshare/src/gxs/rsgds.h @@ -31,14 +31,21 @@ #include #include "inttypes.h" -#include "rsgnp.h" #include "serialiser/rsgxsitems.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& 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& 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 * @return NULL if group does not exist or pointer to grp if found diff --git a/libretroshare/src/gxs/rsgxs.h b/libretroshare/src/gxs/rsgxs.h index 2ee1dc9b5..00f211fab 100644 --- a/libretroshare/src/gxs/rsgxs.h +++ b/libretroshare/src/gxs/rsgxs.h @@ -48,38 +48,9 @@ #define GXS_STATUS_ERROR 3 /* request is in error */ #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 ; -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 diff --git a/libretroshare/src/gxs/rsgxsnetservice.cc b/libretroshare/src/gxs/rsgxsnetservice.cc index 35b17f8dc..e4eaa8e66 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.cc +++ b/libretroshare/src/gxs/rsgxsnetservice.cc @@ -2,13 +2,15 @@ RsGxsNetService::RsGxsNetService(uint16_t servType, 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()) @@ -34,7 +36,7 @@ void RsGxsNetService::recvNxsItemQueue(){ if(ni->transactionNumber != 0){ // accumulate - if(handleTransactionContent(ci)) + if(handleTransaction(ni)) delete ni ; continue ; // don't delete! It's handled by handleRecvChatMsgItem in some specific cases only. @@ -43,11 +45,10 @@ void RsGxsNetService::recvNxsItemQueue(){ switch(ni->PacketSubType()) { - case RS_PKT_SUBTYPE_NXS_SYNC_GRP: handleRecvSyncGroup (dynamic_cast(ni)) ; break ; - case RS_PKT_SUBTYPE_NXS_SYNC_MSG: handleRecvSyncMessage (dynamic_cast(ni)) ; break ; - case RS_PKT_SUBTYPE_NXS_TRANS: handleRecvTransaction (dynamic_cast(ni)) ; break; + case RS_PKT_SUBTYPE_NXS_SYNC_GRP: handleRecvSyncGroup (dynamic_cast(ni)) ; break ; + case RS_PKT_SUBTYPE_NXS_SYNC_MSG: handleRecvSyncMessage (dynamic_cast(ni)) ; break ; 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 ; } @@ -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(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(){ @@ -72,23 +204,421 @@ void RsGxsNetService::run(){ processTransactions(); - processCompleteTransactions(); + processCompletedTransactions(); 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 toRemove; + + for(; mmit != mmit_end; mmit++){ + + NxsTransaction* tr = mmit->second; + uint16_t flag = tr->mFlag; + std::list::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::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 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::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::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::iterator lit = tr->mItems.begin(); + std::list grps; + + for(; lit != tr->mItems.end(); lit++) + { + + RsNxsGrp* grp = dynamic_cast(*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::iterator lit = tr->mItems.begin(); + std::list msgs; + + for(; lit != tr->mItems.end(); lit++) + { + RsNxsMsg* msg = dynamic_cast(*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 msgItemL; + + std::list::iterator lit = tr->mItems.begin(); + + for(; lit != tr->mItems.end(); lit++) + { + RsNxsSyncMsgItem* item = dynamic_cast(*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 msgMap; + mDataStore->retrieveMsgs(grpId, msgMap, false); + + // now do compare and add loop + std::list::iterator llit = msgItemL.begin(); + std::list 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 grpItemL; + + std::list::iterator lit = tr->mItems.begin(); + + for(; lit != tr->mItems.end(); lit++) + { + RsNxsSyncGrpItem* item = dynamic_cast(*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 grpMap; + mDataStore->retrieveGrps(grpMap, false); + + // now do compare and add loop + std::list::iterator llit = grpItemL.begin(); + std::list 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::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::NxsTransaction() :mTransaction(NULL), mFlag(0), mTimestamp(0) { @@ -96,4 +626,5 @@ NxsTransaction::NxsTransaction() NxsTransaction::~NxsTransaction(){ + delete mTransaction; } diff --git a/libretroshare/src/gxs/rsgxsnetservice.h b/libretroshare/src/gxs/rsgxsnetservice.h index 603b83247..9a2691e0f 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.h +++ b/libretroshare/src/gxs/rsgxsnetservice.h @@ -16,16 +16,20 @@ /*! * This represents a transaction made * with the NxsNetService in all states - * of operation untill completion + * of operation until completion */ class NxsTransaction { public: - static const uint8_t FLAG_STATE_RECEIVING; - static const uint8_t FLAG_STATE_DONE; - static const uint8_t FLGA_STATE_COMPLETED; + static const uint8_t FLAG_STATE_STARTING; // when + static const uint8_t FLAG_STATE_RECEIVING; // begin receiving items for incoming trans + 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(); @@ -45,6 +49,20 @@ public: std::list mItems; // items received or sent }; +class NxsGrpSyncTrans : public NxsTransaction { + +public: + +}; + +class NxsMsgSyncTrans : public NxsTransaction { + +public: + std::string mGrpId; +}; + + + /// keep track of transaction number typedef std::map TransactionIdMap; @@ -84,7 +102,7 @@ public: * Circumvents polling of peers for message * @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 @@ -92,7 +110,7 @@ public: * @param peerId Id of peer * @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 @@ -100,7 +118,7 @@ public: * @param grpId the id of the group to subscribe to * @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 @@ -109,7 +127,7 @@ public: * @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 */ - 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 @@ -118,7 +136,7 @@ public: * @param hops number of hops deep into peer network * @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 * @return request token to be redeemed */ - int requestMsg(const std::list& 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 @@ -143,7 +161,7 @@ public: * @param enabled set to false to disable pause, and true otherwise * @return request token to be redeemed */ - int requestGrp(const std::list& grpId, uint8_t hops); + int requestGrp(const std::list& grpId, uint8_t hops){ return 0;} @@ -152,7 +170,7 @@ public: /*! * initiates synchronisation */ - void tick(); + int tick(); /*! * Processes transactions and job queue @@ -168,25 +186,34 @@ private: 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(); /*! - * 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(); - - /*! - * This adds a transaction to - * @param - */ - void locked_addTransaction(NxsTransaction* trans); + bool locked_processTransac(RsNxsTransac* item); /*! * This adds a transaction @@ -197,21 +224,72 @@ private: */ void locked_completeTransaction(NxsTransaction* trans); + /*! + * This retrieves a unique transaction id that + * can be used in an outgoing transaction + */ uint32_t getTransactionId(); + /*! + * This attempts to push the transaction id counter back if you have + * active outgoing transactions in play + */ bool attemptRecoverIds(); - /** item handlers **/ + /*! + * The cb listener is the owner of the grps + * @param grps + */ + void notifyListenerGrps(std::list& grps); - void handleTransactionContent(RsNxsItem*); + /*! + * The cb listener is the owner of the msgs + * @param msgs + */ + void notifyListenerMsgs(std::list& 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: @@ -219,7 +297,7 @@ private: /*** transactions ***/ /// active transactions - TransactionsPeerMap mInTransactions; + TransactionsPeerMap mTransactions; /// completed transactions std::list mComplTransactions; @@ -230,17 +308,17 @@ private: /*** transactions ***/ /*** synchronisation ***/ - std::list mSyncGrp; - std::list mSyncMsg; + std::list mSyncGrp; + std::list mSyncMsg; /*** synchronisation ***/ RsNxsObserver* mObserver; RsGeneralDataService* mDataStore; uint16_t mServType; + uint32_t mTransactionTimeOut; - - /// for transaction members - RsMutex mTransMutex; + std::string mOwnId; +; /// for other members save transactions RsMutex mNxsMutex; diff --git a/libretroshare/src/gxs/rsnxs.h b/libretroshare/src/gxs/rsnxs.h index a73dcb0e9..e647f1700 100644 --- a/libretroshare/src/gxs/rsnxs.h +++ b/libretroshare/src/gxs/rsnxs.h @@ -33,8 +33,8 @@ #include #include -#include "gxs/rsgxs.h" #include "services/p3service.h" +#include "rsgds.h" /*! * Retroshare General Network Exchange Service: \n @@ -60,6 +60,8 @@ class RsNetworkExchangeService : public p3Service { public: + RsNetworkExchangeService(); + /*! * 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 @@ -79,7 +81,7 @@ public: * @param peerId Id of peer * @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 @@ -87,7 +89,7 @@ public: * @param grpId the id of the group to subscribe to * @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 @@ -122,7 +124,7 @@ public: * @param msgId the messages to retrieve * @return request token to be redeemed */ - virtual int requestMsg(const std::list& 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 diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index ad6fb2da9..238124c48 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -666,11 +666,13 @@ newcache { HEADERS += serialiser/rsnxsitems.h \ gxs/rsgds.h \ gxs/rsgxs.h \ - gxs/rsdataservice/h + gxs/rsdataservice/h \ + gxs/rsgxsnetservice.h SOURCES += serialiser/rsnxsitems.cc \ gxs/rsdataservice.cc \ - gxs/rsgenexchange.cc + gxs/rsgenexchange.cc \ + gxs/rsgxsnetservice.cc } diff --git a/libretroshare/src/serialiser/rsnxsitems.cc b/libretroshare/src/serialiser/rsnxsitems.cc index e1488c112..b1c1969a3 100644 --- a/libretroshare/src/serialiser/rsnxsitems.cc +++ b/libretroshare/src/serialiser/rsnxsitems.cc @@ -2,51 +2,57 @@ #include "rsbaseserial.h" #define RSSERIAL_DEBUG -const uint8_t RsSyncGrpList::FLAG_REQUEST = 0x001; -const uint8_t RsSyncGrpList::FLAG_RESPONSE = 0x002; +const uint8_t RsNxsSyncGrpItem::FLAG_REQUEST = 0x001; +const uint8_t RsNxsSyncGrpItem::FLAG_RESPONSE = 0x002; -const uint8_t RsSyncGrpMsgList::FLAG_REQUEST = 0x001; -const uint8_t RsSyncGrpMsgList::FLAG_RESPONSE = 0x002; +const uint8_t RsNxsSyncMsgItem::FLAG_REQUEST = 0x001; +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) { RsNxsGrp* ngp; RsNxsMsg* nmg; - RsSyncGrp* sg; - RsSyncGrpList* sgl; - RsSyncGrpMsg* sgm; - RsSyncGrpMsgList* sgml; + RsNxsSyncGrp* sg; + RsNxsSyncGrpItem* sgl; + RsNxsSyncMsg* sgm; + RsNxsSyncMsgItem* sgml; RsNxsTransac* ntx; - if((sg = dynamic_cast(item)) != NULL) + if((sg = dynamic_cast(item)) != NULL) { - return sizeSyncGrp(sg); + return sizeNxsSyncGrp(sg); }else if(( ntx = dynamic_cast(item)) != NULL){ return sizeNxsTrans(ntx); } - else if ((sgl = dynamic_cast(item)) != NULL) + else if ((sgl = dynamic_cast(item)) != NULL) { - return sizeSyncGrpList(sgl); + return sizeNxsSyncGrpItem(sgl); - }else if ((sgm = dynamic_cast(item)) != NULL) + }else if ((sgm = dynamic_cast(item)) != NULL) { - return sizeSyncGrpMsg(sgm); - }else if ((sgml = dynamic_cast(item)) != NULL) + return sizeNxsSyncMsg(sgm); + }else if ((sgml = dynamic_cast(item)) != NULL) { - return sizeSyncGrpMsgList(sgml); + return sizeNxsSyncMsgItem(sgml); }else if((ngp = dynamic_cast(item)) != NULL) { return sizeNxsGrp(ngp); }else if((nmg = dynamic_cast(item)) != NULL) { 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: - return deserialSyncGrp(data, size); + return deserialNxsSyncGrp(data, size); case RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM: - return deserialSyncGrpList(data, size); + return deserialNxsSyncGrpItem(data, size); case RS_PKT_SUBTYPE_NXS_SYNC_MSG: - return deserialSyncGrpMsg(data, size); + return deserialNxsSyncMsg(data, size); case RS_PKT_SUBTYPE_NXS_SYNC_MSG_ITEM: - return deserialSyncGrpMsgList(data, size); + return deserialNxsSyncMsgItem(data, size); case RS_PKT_SUBTYPE_NXS_GRP: return deserialNxsGrp(data, size); case RS_PKT_SUBTYPE_NXS_MSG: @@ -103,31 +109,31 @@ bool RsNxsSerialiser::serialise(RsItem *item, void *data, uint32_t *size){ RsNxsGrp* ngp; RsNxsMsg* nmg; - RsSyncGrp* sg; - RsSyncGrpList* sgl; - RsSyncGrpMsg* sgm; - RsSyncGrpMsgList* sgml; + RsNxsSyncGrp* sg; + RsNxsSyncGrpItem* sgl; + RsNxsSyncMsg* sgm; + RsNxsSyncMsgItem* sgml; RsNxsExtended* nxt; RsNxsTransac* ntx; - if((sg = dynamic_cast(item)) != NULL) + if((sg = dynamic_cast(item)) != NULL) { - return serialiseSyncGrp(sg, data, size); + return serialiseNxsSyncGrp(sg, data, size); }else if ((ntx = dynamic_cast(item)) != NULL) { return serialiseNxsTrans(ntx, data, size); - }else if ((sgl = dynamic_cast(item)) != NULL) + }else if ((sgl = dynamic_cast(item)) != NULL) { - return serialiseSyncGrpList(sgl, data, size); + return serialiseNxsSyncGrpItem(sgl, data, size); - }else if ((sgm = dynamic_cast(item)) != NULL) + }else if ((sgm = dynamic_cast(item)) != NULL) { - return serialiseSyncGrpMsg(sgm, data, size); - }else if ((sgml = dynamic_cast(item)) != NULL) + return serialiseNxsSyncMsg(sgm, data, size); + }else if ((sgml = dynamic_cast(item)) != NULL) { - return serialiseSynGrpMsgList(sgml, data, size); + return serialiseNxsSynMsgItem(sgml, data, size); }else if((ngp = dynamic_cast(item)) != NULL) { 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 - std::cerr << "RsNxsSerialiser::serialiseSynGrpMsgList()" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem()" << std::endl; #endif - uint32_t tlvsize = sizeSyncGrpMsgList(item); + uint32_t tlvsize = sizeNxsSyncMsgItem(item); uint32_t offset = 0; if(*size < tlvsize){ #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSynGrpMsgList()" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem()" << std::endl; #endif return false; } @@ -173,17 +179,16 @@ bool RsNxsSerialiser::serialiseSynGrpMsgList(RsSyncGrpMsgList *item, void *data, /* skip the header */ 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 &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId); - ok &= item->idSign.SetTlv(data, *size, &offset); if(offset != tlvsize){ #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSynGrpMsgList() FAIL Size Error! " << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem() FAIL Size Error! " << std::endl; #endif ok = false; } @@ -191,7 +196,7 @@ bool RsNxsSerialiser::serialiseSynGrpMsgList(RsSyncGrpMsgList *item, void *data, #ifdef RSSERIAL_DEBUG if (!ok) { - std::cerr << "RsNxsSerialiser::serialiseSynGrpMsgList() NOK" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSynMsgItem() NOK" << std::endl; } #endif @@ -225,8 +230,9 @@ bool RsNxsSerialiser::serialiseNxsMsg(RsNxsMsg *item, void *data, uint32_t *size /* skip the header */ 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->originalMsgId); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity); ok &= setRawUInt32(data, tlvsize, &offset, item->timeStamp); @@ -280,7 +286,7 @@ bool RsNxsSerialiser::serialiseNxsGrp(RsNxsGrp *item, void *data, uint32_t *size offset += 8; // 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_NAME, item->identity); ok &= setRawUInt32(data, tlvsize, &offset, item->grpFlag); @@ -307,19 +313,19 @@ bool RsNxsSerialiser::serialiseNxsGrp(RsNxsGrp *item, void *data, uint32_t *size 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 - std::cerr << "RsNxsSerialiser::serialiseSyncGrp()" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrp()" << std::endl; #endif - uint32_t tlvsize = sizeSyncGrp(item); + uint32_t tlvsize = sizeNxsSyncGrp(item); uint32_t offset = 0; if(*size < tlvsize){ #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSyncGrp()" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrp()" << std::endl; #endif return false; } @@ -333,7 +339,7 @@ bool RsNxsSerialiser::serialiseSyncGrp(RsSyncGrp *item, void *data, uint32_t *si /* skip the header */ offset += 8; - ok &= setRawUInt32(data, *size, &offset, item->transactionId); + ok &= setRawUInt32(data, *size, &offset, item->transactionNumber); ok &= setRawUInt8(data, *size, &offset, item->flag); ok &= setRawUInt32(data, *size, &offset, item->syncAge); 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 */ offset += 8; - ok &= setRawUInt32(data, *size, &offset, item->transactionId); + ok &= setRawUInt32(data, *size, &offset, item->transactionNumber); ok &= setRawUInt16(data, *size, &offset, item->transactFlag); ok &= setRawUInt32(data, *size, &offset, item->nItems); 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; } -bool RsNxsSerialiser::serialiseSyncGrpList(RsSyncGrpList *item, void *data, uint32_t *size) +bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data, uint32_t *size) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSyncGrpList()" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem()" << std::endl; #endif - uint32_t tlvsize = sizeSyncGrpList(item); + uint32_t tlvsize = sizeNxsSyncGrpItem(item); uint32_t offset = 0; if(*size < tlvsize){ #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSyncGrpList() size do not match" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem() size do not match" << std::endl; #endif return false; } @@ -431,16 +436,16 @@ bool RsNxsSerialiser::serialiseSyncGrpList(RsSyncGrpList *item, void *data, uint /* skip the header */ 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 &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= item->adminSign.SetTlv(data, *size, &offset); if(offset != tlvsize){ #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSyncGrpList( FAIL Size Error! " << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem( FAIL Size Error! " << std::endl; #endif ok = false; } @@ -448,7 +453,7 @@ bool RsNxsSerialiser::serialiseSyncGrpList(RsSyncGrpList *item, void *data, uint #ifdef RSSERIAL_DEBUG if (!ok) { - std::cerr << "RsNxsSerialiser::serialiseSyncGrpList() NOK" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem() NOK" << std::endl; } #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 - std::cerr << "RsNxsSerialiser::serialiseSyncGrpMsg()" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg()" << std::endl; #endif - uint32_t tlvsize = sizeSyncGrpMsg(item); + uint32_t tlvsize = sizeNxsSyncMsg(item); uint32_t offset = 0; if(*size < tlvsize){ #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSyncGrpMsg()" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg()" << std::endl; #endif return false; } @@ -480,7 +485,7 @@ bool RsNxsSerialiser::serialiseSyncGrpMsg(RsSyncGrpMsg *item, void *data, uint32 /* skip the header */ offset += 8; - ok &= setRawUInt32(data, *size, &offset, item->transactionId); + ok &= setRawUInt32(data, *size, &offset, item->transactionNumber); ok &= setRawUInt8(data, *size, &offset, item->flag); ok &= setRawUInt32(data, *size, &offset, item->syncAge); 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){ #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::serialiseSyncGrpMsg() FAIL Size Error! " << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg() FAIL Size Error! " << std::endl; #endif ok = false; } @@ -496,7 +501,7 @@ bool RsNxsSerialiser::serialiseSyncGrpMsg(RsSyncGrpMsg *item, void *data, uint32 #ifdef RSSERIAL_DEBUG if (!ok) { - std::cerr << "RsNxsSerialiser::serialiseSyncGrpMsg( NOK" << std::endl; + std::cerr << "RsNxsSerialiser::serialiseNxsSyncMsg( NOK" << std::endl; } #endif @@ -626,6 +631,7 @@ RsNxsMsg* RsNxsSerialiser::deserialNxsMsg(void *data, uint32_t *size){ 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->originalMsgId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->identity); 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 - std::cerr << "RsNxsSerialiser::deserialSyncGrp()" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp()" << std::endl; #endif /* get the type and size */ 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))) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrp() FAIL wrong type" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() FAIL wrong type" << std::endl; #endif return NULL; /* wrong type */ } @@ -682,7 +688,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){ if (*size < rssize) /* check size */ { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrp() FAIL wrong size" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() FAIL wrong size" << std::endl; #endif return NULL; /* not enough data */ } @@ -692,7 +698,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){ bool ok = true; - RsSyncGrp* item = new RsSyncGrp(getRsItemService(rstype)); + RsNxsSyncGrp* item = new RsNxsSyncGrp(getRsItemService(rstype)); /* skip the header */ offset += 8; @@ -704,7 +710,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){ if (offset != rssize) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrp() FAIL size mismatch" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() FAIL size mismatch" << std::endl; #endif /* error */ delete item; @@ -714,7 +720,7 @@ RsSyncGrp* RsNxsSerialiser::deserialSyncGrp(void *data, uint32_t *size){ if (!ok) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrp() NOK" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp() NOK" << std::endl; #endif delete item; 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 - std::cerr << "RsNxsSerialiser::deserialSyncGrpList()" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem()" << std::endl; #endif /* get the type and size */ 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))) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpList() FAIL wrong type" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() FAIL wrong type" << std::endl; #endif return NULL; /* wrong type */ } @@ -749,7 +755,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){ if (*size < rssize) /* check size */ { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpList() FAIL wrong size" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() FAIL wrong size" << std::endl; #endif return NULL; /* not enough data */ } @@ -759,7 +765,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){ bool ok = true; - RsSyncGrpList* item = new RsSyncGrpList(SERVICE_TYPE); + RsNxsSyncGrpItem* item = new RsNxsSyncGrpItem(SERVICE_TYPE); /* skip the header */ offset += 8; @@ -771,7 +777,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){ if (offset != rssize) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpList() FAIL size mismatch" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() FAIL size mismatch" << std::endl; #endif /* error */ delete item; @@ -781,7 +787,7 @@ RsSyncGrpList* RsNxsSerialiser::deserialSyncGrpList(void *data, uint32_t *size){ if (!ok) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpList() NOK" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrpItem() NOK" << std::endl; #endif delete item; return NULL; @@ -815,7 +821,7 @@ RsNxsTransac* RsNxsSerialiser::deserialNxsTrans(void *data, uint32_t *size){ if (*size < rssize) /* check size */ { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList( FAIL wrong size" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem( FAIL wrong size" << std::endl; #endif 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 &= getRawUInt32(data, *size, &offset, &(item->nItems)); ok &= getRawUInt32(data, *size, &offset, &(item->timeout)); - ok &= getRawUInt32(data, *size, &offset, &(item->transactionId)); 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 - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList()" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem()" << std::endl; #endif /* get the type and size */ uint32_t rstype = getRsItemId(data); @@ -874,10 +879,10 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t * if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(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 - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList() FAIL wrong type" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem() FAIL wrong type" << std::endl; #endif return NULL; /* wrong type */ } @@ -885,7 +890,7 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t * if (*size < rssize) /* check size */ { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList( FAIL wrong size" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem( FAIL wrong size" << std::endl; #endif return NULL; /* not enough data */ } @@ -895,7 +900,7 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t * bool ok = true; - RsSyncGrpMsgList* item = new RsSyncGrpMsgList(getRsItemService(rstype)); + RsNxsSyncMsgItem* item = new RsNxsSyncMsgItem(getRsItemService(rstype)); /* skip the header */ offset += 8; @@ -903,12 +908,11 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t * ok &= getRawUInt8(data, *size, &offset, &(item->flag)); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId); - ok &= item->idSign.GetTlv(data, *size, &offset); if (offset != rssize) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList() FAIL size mismatch" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem() FAIL size mismatch" << std::endl; #endif /* error */ delete item; @@ -918,7 +922,7 @@ RsSyncGrpMsgList* RsNxsSerialiser::deserialSyncGrpMsgList(void *data, uint32_t * if (!ok) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsgList() NOK" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsgItem() NOK" << std::endl; #endif delete item; 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 - std::cerr << "RsNxsSerialiser::deserialSyncGrp()" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncGrp()" << std::endl; #endif /* get the type and size */ uint32_t rstype = getRsItemId(data); @@ -944,10 +948,10 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size) if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (SERVICE_TYPE != getRsItemService(rstype)) || - (RS_PKT_SUBTYPE_SYNC_MSG != getRsItemSubType(rstype))) + (RS_PKT_SUBTYPE_NXS_SYNC_MSG != getRsItemSubType(rstype))) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsg() FAIL wrong type" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() FAIL wrong type" << std::endl; #endif return NULL; /* wrong type */ } @@ -955,7 +959,7 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size) if (*size < rssize) /* check size */ { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsg() FAIL wrong size" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() FAIL wrong size" << std::endl; #endif return NULL; /* not enough data */ } @@ -965,7 +969,7 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size) bool ok = true; - RsSyncGrpMsg* item = new RsSyncGrpMsg(getRsItemService(rstype)); + RsNxsSyncMsg* item = new RsNxsSyncMsg(getRsItemService(rstype)); /* skip the header */ offset += 8; @@ -979,7 +983,7 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size) if (offset != rssize) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsg() FAIL size mismatch" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() FAIL size mismatch" << std::endl; #endif /* error */ delete item; @@ -989,7 +993,7 @@ RsSyncGrpMsg* RsNxsSerialiser::deserialSyncGrpMsg(void *data, uint32_t *size) if (!ok) { #ifdef RSSERIAL_DEBUG - std::cerr << "RsNxsSerialiser::deserialSyncGrpMsg() NOK" << std::endl; + std::cerr << "RsNxsSerialiser::deserialNxsSyncMsg() NOK" << std::endl; #endif delete item; return NULL; @@ -1013,9 +1017,11 @@ uint32_t RsNxsSerialiser::sizeNxsMsg(RsNxsMsg *item) uint32_t s = 8; //header size + s += 4; // transaction number s += GetTlvStringSize(item->grpId); s += GetTlvStringSize(item->msgId); s += GetTlvStringSize(item->identity); + s += GetTlvStringSize(item->originalMsgId); s += 4; // msgFlag s += 4; // timeStamp 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 @@ -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 @@ -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; @@ -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 @@ -1092,7 +1098,6 @@ uint32_t RsNxsSerialiser::sizeSyncGrpMsgList(RsSyncGrpMsgList *item) s += 1; // flag s += GetTlvStringSize(item->grpId); s += GetTlvStringSize(item->msgId); - s += item->idSign.TlvSize(); return s; } @@ -1105,7 +1110,6 @@ uint32_t RsNxsSerialiser::sizeNxsTrans(RsNxsTransac *item){ s += 2; // flag s += 4; // nMsgs s += 4; // timeout - s += 4; // transaction id return s; } @@ -1128,6 +1132,7 @@ void RsNxsMsg::clear() publishSign.TlvClear(); idSign.TlvClear(); identity.clear(); + originalMsgId.clear(); } void RsNxsGrp::clear() @@ -1142,14 +1147,14 @@ void RsNxsGrp::clear() idSign.TlvClear(); } -void RsSyncGrp::clear() +void RsNxsSyncGrp::clear() { flag = 0; syncAge = 0; syncHash.clear(); } -void RsSyncGrpMsg::clear() +void RsNxsSyncMsg::clear() { grpId.clear(); flag = 0; @@ -1157,18 +1162,17 @@ void RsSyncGrpMsg::clear() syncHash.clear(); } -void RsSyncGrpList::clear() +void RsNxsSyncGrpItem::clear() { flag = 0; adminSign.TlvClear(); grpId.clear(); } -void RsSyncGrpMsgList::clear() +void RsNxsSyncMsgItem::clear() { flag = 0; msgId.clear(); - idSign.TlvClear(); grpId.clear(); } @@ -1176,13 +1180,13 @@ void RsNxsTransac::clear(){ transactFlag = 0; nItems = 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; printIndent(out , int_Indent); @@ -1193,7 +1197,7 @@ std::ostream& RsSyncGrp::print(std::ostream &out, uint16_t indent) out << "flag" << flag << std::endl; - printRsItemEnd(out ,"RsSyncGrp", indent); + printRsItemEnd(out ,"RsNxsSyncGrp", indent); return out; } @@ -1212,9 +1216,9 @@ std::ostream& RsNxsExtended::print(std::ostream &out, uint16_t indent){ 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; printIndent(out , int_Indent); @@ -1226,13 +1230,13 @@ std::ostream& RsSyncGrpMsg::print(std::ostream &out, uint16_t indent) printIndent(out , int_Indent); out << "flag: " << flag << std::endl; - printRsItemEnd(out, "RsSyncGrpMsg", indent); + printRsItemEnd(out, "RsNxsSyncMsg", indent); 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; printIndent(out , int_Indent); @@ -1243,15 +1247,15 @@ std::ostream& RsSyncGrpList::print(std::ostream &out, uint16_t indent) adminSign.print(out, indent); printIndent(out , int_Indent); - printRsItemEnd(out , "RsSyncGrpList", indent); + printRsItemEnd(out , "RsNxsSyncGrpItem", indent); 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; printIndent(out , int_Indent); @@ -1261,10 +1265,8 @@ std::ostream& RsSyncGrpMsgList::print(std::ostream &out, uint16_t indent) printIndent(out , int_Indent); out << "msgId: " << msgId << std::endl; printIndent(out , int_Indent); - idSign.print(out, indent); - printIndent(out , int_Indent); - printRsItemEnd(out ,"RsSyncGrpMsgList", indent); + printRsItemEnd(out ,"RsNxsSyncMsgItem", indent); return out; } @@ -1327,7 +1329,7 @@ std::ostream& RsNxsTransac::print(std::ostream &out, uint16_t indent){ printIndent(out , int_Indent); out << "timeout: " << timeout << std::endl; printIndent(out , int_Indent); - out << "transactionId: " << transactionId << std::endl; + out << "transactionNumber: " << transactionNumber << std::endl; printIndent(out , int_Indent); printRsItemEnd(out ,"RsNxsTransac", indent); diff --git a/libretroshare/src/serialiser/rsnxsitems.h b/libretroshare/src/serialiser/rsnxsitems.h index ff96f34bd..1d0712e1c 100644 --- a/libretroshare/src/serialiser/rsnxsitems.h +++ b/libretroshare/src/serialiser/rsnxsitems.h @@ -88,7 +88,7 @@ public: 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 - 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 std::ostream &print(std::ostream &out, uint16_t indent); @@ -111,6 +111,9 @@ class RsNxsTransac : public RsNxsItem { public: + static const uint16_t FLAG_TRANS_MASK = 0xf; + static const uint16_t FLAG_TYPE_MASK = 0xff; + /** transaction **/ static const uint16_t FLAG_BEGIN_P1; 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_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 void clear(); @@ -138,7 +141,6 @@ public: uint16_t transactFlag; uint32_t nItems; uint32_t timeout; - uint32_t transactionId; }; /*! @@ -154,8 +156,8 @@ public: static const uint8_t FLAG_RESPONSE; static const uint8_t FLAG_USE_SYNC_HASH; - RsNxsSyncGrpItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM) { return ; } - virtual ~RsNxsSyncGrpList() { return; } + RsNxsSyncGrpItem(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_SYNC_GRP_ITEM) { clear(); return ; } + virtual ~RsNxsSyncGrpItem() { return; } virtual void clear(); virtual std::ostream &print(std::ostream &out, uint16_t indent); @@ -179,7 +181,7 @@ class RsNxsGrp : public RsNxsItem 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(); @@ -206,7 +208,7 @@ public: 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(); @@ -229,7 +231,7 @@ public: static const uint8_t FLAG_REQUEST; static const uint8_t FLAG_RESPONSE; 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 std::ostream &print(std::ostream &out, uint16_t indent); @@ -249,7 +251,7 @@ class RsNxsMsg : public RsNxsItem { 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(); @@ -397,11 +399,11 @@ private: virtual bool serialiseNxsSyncGrp(RsNxsSyncGrp *item, 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 bool serialiseNxsSyncGrpList(RsNxsSyncGrpItem *item, void *data, uint32_t *size); - virtual RsNxsSyncGrpItem* deserialNxsSyncGrpList(void *data, uint32_t *size); + virtual uint32_t sizeNxsSyncGrpItem(RsNxsSyncGrpItem* item); + virtual bool serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data, uint32_t *size); + virtual RsNxsSyncGrpItem* deserialNxsSyncGrpItem(void *data, uint32_t *size); /* for RS_PKT_SUBTYPE_NXS_GRP */ @@ -411,15 +413,15 @@ private: /* for RS_PKT_SUBTYPE_SYNC_MSG */ - virtual uint32_t sizeSyncGrpMsg(RsSyncGrpMsg* item); - virtual bool serialiseSyncGrpMsg(RsSyncGrpMsg *item, void *data, uint32_t *size); - virtual RsSyncGrpMsg* deserialSyncGrpMsg(void *data, uint32_t *size); + virtual uint32_t sizeNxsSyncMsg(RsNxsSyncMsg* item); + virtual bool serialiseNxsSyncMsg(RsNxsSyncMsg *item, 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 bool serialiseSynGrpMsgList(RsSyncGrpMsgList* item, void *data, uint32_t* size); - virtual RsSyncGrpMsgList* deserialSyncGrpMsgList(void *data, uint32_t *size); + virtual uint32_t sizeNxsSyncMsgItem(RsNxsSyncMsgItem* item); + virtual bool serialiseNxsSynMsgItem(RsNxsSyncMsgItem* item, void *data, uint32_t* size); + virtual RsNxsSyncMsgItem* deserialNxsSyncMsgItem(void *data, uint32_t *size); /* 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 diff --git a/libretroshare/src/tests/gxs/rsdataservice_test.cc b/libretroshare/src/tests/gxs/rsdataservice_test.cc index d70f5d1d3..35c43bfa2 100644 --- a/libretroshare/src/tests/gxs/rsdataservice_test.cc +++ b/libretroshare/src/tests/gxs/rsdataservice_test.cc @@ -21,8 +21,6 @@ int main() test_messageStoresAndRetrieve(); REPORT("test_messageStoresAndRetrieve"); - test_messageVersionRetrieve(); REPORT("test_messageVersionRetrieve"); - test_groupVersionRetrieve(); REPORT("test_groupVersionRetrieve"); FINALREPORT("RsDataService Tests"); @@ -138,48 +136,6 @@ void test_messageStoresAndRetrieve(){ tearDown(); } -void test_messageVersionRetrieve(){ - - setUp(); - - // place two messages in store and attempt to retrieve them - std::set 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(){ diff --git a/libretroshare/src/tests/serialiser/rsnxsitems_test.cc b/libretroshare/src/tests/serialiser/rsnxsitems_test.cc index 810db6310..1acf49a7c 100644 --- a/libretroshare/src/tests/serialiser/rsnxsitems_test.cc +++ b/libretroshare/src/tests/serialiser/rsnxsitems_test.cc @@ -15,6 +15,7 @@ RsSerialType* init_item(RsNxsGrp& nxg) randString(SHORT_STR, nxg.identity); randString(SHORT_STR, nxg.grpId); nxg.timeStamp = rand()%23; + nxg.transactionNumber = rand()%23; nxg.grpFlag = rand()%242; init_item(nxg.grp); @@ -46,38 +47,41 @@ RsSerialType* init_item(RsNxsMsg& nxm) init_item(nxm.msg); nxm.msgFlag = rand()%4252; nxm.timeStamp = rand()%246; + nxm.transactionNumber = rand()%23; return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); } -RsSerialType* init_item(RsSyncGrp& rsg) +RsSerialType* init_item(RsNxsSyncGrp& rsg) { rsg.clear(); - rsg.flag = RsSyncGrp::FLAG_USE_SYNC_HASH; + rsg.flag = RsNxsSyncGrp::FLAG_USE_SYNC_HASH; rsg.syncAge = rand()%2423; randString(3124,rsg.syncHash); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); } -RsSerialType* init_item(RsSyncGrpMsg& rsgm) +RsSerialType* init_item(RsNxsSyncMsg& rsgm) { rsgm.clear(); - rsgm.flag = RsSyncGrpMsg::FLAG_USE_SYNC_HASH; + rsgm.flag = RsNxsSyncMsg::FLAG_USE_SYNC_HASH; rsgm.syncAge = rand()%24232; + rsgm.transactionNumber = rand()%23; randString(SHORT_STR, rsgm.grpId); randString(SHORT_STR, rsgm.syncHash); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); } -RsSerialType* init_item(RsSyncGrpList& rsgl) +RsSerialType* init_item(RsNxsSyncGrpItem& rsgl) { rsgl.clear(); - rsgl.flag = RsSyncGrpList::FLAG_RESPONSE; + rsgl.flag = RsNxsSyncGrpItem::FLAG_RESPONSE; + rsgl.transactionNumber = rand()%23; randString(SHORT_STR, rsgl.grpId); init_item(rsgl.adminSign); @@ -85,14 +89,14 @@ RsSerialType* init_item(RsSyncGrpList& rsgl) return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); } -RsSerialType* init_item(RsSyncGrpMsgList& rsgml) +RsSerialType* init_item(RsNxsSyncMsgItem& rsgml) { 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.msgId); - init_item(rsgml.idSign); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); } @@ -104,7 +108,7 @@ RsSerialType* init_item(RsNxsTransac& rstx){ rstx.timeout = rand()%14141; rstx.transactFlag = rand()%2424; rstx.nItems = rand()%33132; - rstx.transactionId = rand()%242112; + rstx.transactionNumber = rand()%242112; 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.keys.groupId != r.keys.groupId) return false; if(!(l.grp == r.grp) ) return false; + if(l.transactionNumber != r.transactionNumber) return false; std::map::const_iterator mit = 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.publishSign == r.publishSign) ) return false; if(! (l.idSign == r.idSign) ) return false; + if(l.transactionNumber != r.transactionNumber) return false; 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.flag != r.flag) return false; if(l.syncAge != r.syncAge) return false; + if(l.transactionNumber != r.transactionNumber) return false; 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.syncAge != r.syncAge) return false; if(l.syncHash != r.syncHash) return false; if(l.grpId != r.grpId) return false; + if(l.transactionNumber != r.transactionNumber) return false; 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.adminSign == r.adminSign) ) return false; if(l.grpId != r.grpId) return false; + if(l.transactionNumber != r.transactionNumber) return false; 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.grpId != r.grpId) 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; } @@ -190,7 +199,7 @@ bool operator==(const RsSyncGrpMsgList& l, const RsSyncGrpMsgList& r) bool operator==(const RsNxsTransac& l, const RsNxsTransac& r){ 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.nItems != r.nItems) return false; @@ -204,10 +213,10 @@ int main() test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsGrpResp"); test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsGrpMsgResp"); - test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrp"); - test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpMsg"); - test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpList"); - test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpMsgList"); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsSyncGrp"); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsSyncMsg"); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsSyncGrpItem"); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsSyncMsgItem"); test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsNxsTransac"); FINALREPORT("RsNxsItem Tests"); diff --git a/libretroshare/src/tests/serialiser/rsnxsitems_test.h b/libretroshare/src/tests/serialiser/rsnxsitems_test.h index e992007be..31dae24b7 100644 --- a/libretroshare/src/tests/serialiser/rsnxsitems_test.h +++ b/libretroshare/src/tests/serialiser/rsnxsitems_test.h @@ -6,18 +6,18 @@ RsSerialType* init_item(RsNxsGrp&); RsSerialType* init_item(RsNxsMsg&); -RsSerialType* init_item(RsSyncGrp&); -RsSerialType* init_item(RsSyncGrpMsg&); -RsSerialType* init_item(RsSyncGrpList&); -RsSerialType* init_item(RsSyncGrpMsgList&); +RsSerialType* init_item(RsNxsSyncGrp&); +RsSerialType* init_item(RsNxsSyncMsg&); +RsSerialType* init_item(RsNxsSyncGrpItem&); +RsSerialType* init_item(RsNxsSyncMsgItem&); RsSerialType* init_item(RsNxsTransac& ); bool operator==(const RsNxsGrp&, const RsNxsGrp&); bool operator==(const RsNxsMsg&, const RsNxsMsg&); -bool operator==(const RsSyncGrp&, const RsSyncGrp&); -bool operator==(const RsSyncGrpMsg&, const RsSyncGrpMsg&); -bool operator==(const RsSyncGrpList&, const RsSyncGrpList&); -bool operator==(const RsSyncGrpMsgList&, const RsSyncGrpMsgList&); +bool operator==(const RsNxsSyncGrp&, const RsNxsSyncGrp&); +bool operator==(const RsNxsSyncMsg&, const RsNxsSyncMsg&); +bool operator==(const RsNxsSyncGrpItem&, const RsNxsSyncGrpItem&); +bool operator==(const RsNxsSyncMsgItem&, const RsNxsSyncMsgItem&); bool operator==(const RsNxsTransac&, const RsNxsTransac& ); diff --git a/libretroshare/src/tests/serialiser/support.h b/libretroshare/src/tests/serialiser/support.h index 24c62637f..9f2f8868d 100644 --- a/libretroshare/src/tests/serialiser/support.h +++ b/libretroshare/src/tests/serialiser/support.h @@ -165,7 +165,7 @@ template int test_RsItem(uint16_t servtype) /* initialise */ 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 */ @@ -216,7 +216,6 @@ template int test_RsItem(uint16_t servtype) // displayRawPacket(std::cerr, (void *) buffer, 16 * 8 + sersize2); delete[] buffer ; - //delete rsfis; return 1; }