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; }