// SMsgDirG2ExplicitSetDataObjects::Pack // Virtual method from SmallMessage. Packs data into message buffer. void* SMsgDirG2ExplicitSetDataObjects::Pack(void) { WTRACE("SMsgDirG2ExplicitSetDataObjects::Pack"); SetServiceType(WONMsg::SmallDirServerG2); SetMessageType(mKeyType == KT_SERVICE ? WONMsg::DirG2ServiceExplicitSetDataObjects : WONMsg::DirG2DirectoryExplicitSetDataObjects); SMsgDirG2UpdateBase::Pack(); PackKey(*this); AppendShort(mObjects.size()); ExplicitDOInfoList::iterator anItr(mObjects.begin()); for (; anItr != mObjects.end(); anItr++) { AppendByte(static_cast<unsigned char>(anItr->mSetMode)); unsigned char aTypeLen = anItr->mData.GetDataType().size(); AppendByte(aTypeLen); if (aTypeLen > 0) AppendBytes(aTypeLen, anItr->mData.GetDataType().data()); unsigned short aDataLen = anItr->mData.GetData().size(); AppendShort(aDataLen); if (aDataLen > 0) AppendBytes(aDataLen, anItr->mData.GetData().data()); } PackPeerData(); return GetDataPtr(); }
// TMsgAuth1Complete::Pack // Virtual method from TMessage. Packs data into message buffer and // sets the new message length. void* TMsgAuth1Complete::Pack(void) { WTRACE("TMsgAuth1Complete::Pack"); SetServiceType(WONMsg::Auth1PeerToPeer); SetMessageType(WONMsg::Auth1Complete); TMsgAuthRawBufferBase::Pack(); WDBG_LL("TMsgAuth1Complete::Pack Appending message data"); AppendShort(static_cast<short>(mStatus)); // Append error info if status implies failure if (mStatus < 0) { WDBG_LL("TMsgAuth1Complete::Pack Failure status, append error info"); AppendShort(mErrList.size()); ErrorList::iterator anItr(mErrList.begin()); for (; anItr != mErrList.end(); anItr++) Append_PA_STRING(*anItr); } // Otherwise append success info else { WDBG_LL("TMsgAuth1Complete::Pack Success status, append secret and optional session"); PackRawBuf(); if (mSessionId != 0) AppendShort(mSessionId); } return GetDataPtr(); }
void* MMsgRoutingModifyDataObject::Pack(void) { WTRACE("MMsgRoutingModifyDataObject::Pack"); SetServiceType(WONMsg::MiniRoutingServer); SetMessageType(WONMsg::RoutingModifyDataObject); RoutingServerMessage::Pack(); WDBG_LL("MMsgRoutingModifyDataObject::Pack Appending message data"); // append the client/group id AppendClientOrGroupId(mLinkId); // append the datatype, preceded by datatype length AppendByte(mDataType.size()); AppendBytes(mDataType.size(), mDataType.data()); // append the offset AppendShort(mOffset); // append the IsInsert flag AppendBool(mIsInsert); // append the data length followed by the data itself AppendShort(mData.size()); AppendBytes(mData.size(), mData.data()); return GetDataPtr(); }
// TMsgDirFindServiceReply::Pack // Virtual method from TMessage. Packs data into message buffer and // sets the new message length. void* TMsgDirFindServiceReply::Pack(void) { WTRACE("TMsgDirFindServiceReply::Pack"); SetServiceType(WONMsg::DirServer); SetMessageType(WONMsg::DirFindServiceReply); TMessage::Pack(); WDBG_LL("TMsgDirFindServiceReply::Pack Appending message data"); AppendShort(static_cast<short>(mStatus)); // Service info only sent if status is ok if (mStatus == WONMsg::StatusCommon_Success) { Append_PW_STRING(mService.mPath); Append_PW_STRING(mService.mName); Append_PW_STRING(mService.mDisplayName); Append_PW_STRING(mService.mVersion); Append_PW_STRING(mService.mProtoName); Append_PW_STRING(mService.mProtoVersion); Append_PW_STRING(mService.mNetAddress); AppendLong(mService.mLifespan); AppendLong(mService.mCreated); AppendShort(mService.mBlobLen); AppendBytes(mService.mBlobLen, mService.mBlob); } return GetDataPtr(); }
// MMsgCommMRTGRequest::Pack // Virtual method from MiniMessage. Packs data into message buffer and // sets the new message length. void* MMsgCommMRTGRequest::Pack(void) { WTRACE("MMsgCommMRTGRequest::Pack"); SetServiceType(WONMsg::MiniCommonService); SetMessageType(WONMsg::MiniCommMRTGRequest); MiniMessage::Pack(); AppendShort(mPrimaryID); AppendShort(mSecondaryID); AppendRawString(mPrimaryOption); AppendRawString(mSecondaryOption); return GetDataPtr(); }
void* MMsgRoutingSendData::Pack(void) { WTRACE("MMsgRoutingSendData::Pack"); SetServiceType(WONMsg::MiniRoutingServer); SetMessageType(WONMsg::RoutingSendData); RoutingServerMessage::Pack(); WDBG_LL("MMsgRoutingSendData::Pack Appending message data"); // append the flags unsigned char aFlags = 0; if (mShouldSendReply) aFlags |= 0x01; if (mIncludeExcludeFlag) aFlags |= 0x02; AppendByte(aFlags); // append the message length and data _ASSERT(mData.size() <= USHRT_MAX); AppendShort(mData.size()); AppendBytes(mData.size(), mData.data()); // append the addressee list AppendAddresseeList(this); return GetDataPtr(); }
void* MMsgRoutingCreateGroup::Pack(void) { WTRACE("MMsgRoutingCreateGroup::Pack"); SetServiceType(WONMsg::MiniRoutingServer); SetMessageType(WONMsg::RoutingCreateGroup); RoutingServerMessage::Pack(); WDBG_LL("MMsgRoutingCreateGroup::Pack Appending message data"); // append group name AppendGroupName(mGroupName); // append flags unsigned char aFlags = 0; if (mIsPublic) aFlags |= 0x01; if (mAnnounceGroupChanges) aFlags |= 0x02; AppendByte(aFlags); // append client count _ASSERT(mClientList.size() <= USHRT_MAX); AppendShort(mClientList.size()); // append client list std::list<unsigned short>::iterator itr = mClientList.begin(); while (itr != mClientList.end()) AppendClientId(*(itr++)); return GetDataPtr(); }
void TMsgDirGetDirContentsReply::PackEntry(const DirServerEntry& theEntry) { WTRACE("TMsgDirGetDirContentsReply::PackEntry"); WDBG_LL("TMsgDirGetDirContentsReply::PackEntry Packing entry"); AppendByte(theEntry.mType); Append_PW_STRING(theEntry.mPath); Append_PW_STRING(theEntry.mName); Append_PW_STRING(theEntry.mDisplayName); AppendLong(theEntry.mLifespan); AppendLong(theEntry.mCreated); if (theEntry.mType == DirServerEntry::EntryTypeDirectory) { AppendByte(theEntry.mVisible ? 1 : 0); } else if (theEntry.mType == DirServerEntry::EntryTypeService) { Append_PW_STRING(theEntry.mVersion); Append_PW_STRING(theEntry.mProtoName); Append_PW_STRING(theEntry.mProtoVersion); Append_PW_STRING(theEntry.mNetAddress); AppendShort(theEntry.mBlobLen); AppendBytes(theEntry.mBlobLen, theEntry.mBlob); } }
// MMsgCommGetNumUsersReply::Pack // Virtual method from MiniMessage. Packs data into message buffer and // sets the new message length. void* MMsgCommGetNumUsersReply::Pack(void) { WTRACE("MMsgCommGetNumUsersReply::Pack"); SetServiceType(WONMsg::MiniCommonService); SetMessageType(WONMsg::MiniCommGetNumUsersReply); MiniMessage::Pack(); WDBG_LL("MMsgCommGetNumUsersReply::Pack Appending message data"); AppendShort(mTag); AppendShort(mNumActiveUsers); AppendShort(mUserCapacity); return GetDataPtr(); }
void SMsgDirG2UpdateExtendBase::PackExtended(void) { WTRACE("SMsgDirG2UpdateExtendBase::PackExtended"); WDBG_LL("SMsgDirG2UpdateExtendBase::PackExtended enableDataObjects=" << mEnableDataObjects << " enableACLs=" << mEnableACLs); if (mEnableDataObjects) { WDBG_LL("SMsgDirG2UpdateExtendBase::PackExtended Writing " << mDataObjects.size() << " data objects."); AppendShort(mDataObjects.size()); DataObjectTypeSet::iterator anItr(mDataObjects.begin()); for (; anItr != mDataObjects.end(); anItr++) { unsigned char aTypeLen = anItr->GetDataType().size(); AppendByte(aTypeLen); if (aTypeLen > 0) AppendBytes(aTypeLen, anItr->GetDataType().data()); unsigned short aDataLen = anItr->GetData().size(); AppendShort(aDataLen); if (aDataLen > 0) AppendBytes(aDataLen, anItr->GetData().data()); } } if (mEnableACLs) { WDBG_LL("SMsgDirG2UpdateExtendBase::PackExtended Writing " << mACLs.size() << " ACLs."); AppendShort(mACLs.size()); DirACLList::const_iterator anACLItr(mACLs.begin()); for (; anACLItr != mACLs.end(); anACLItr++) { AppendByte(anACLItr->mType); AppendShort(anACLItr->mACL.size()); PermissionACL::const_iterator aPermItr(anACLItr->mACL.begin()); for (; aPermItr != anACLItr->mACL.end(); aPermItr++) { AppendLong(aPermItr->mUserId); AppendLong(aPermItr->mCommunityId); AppendShort(aPermItr->mTrustLevel); } } } }
// TMsgDirGetDirContents::Pack // Virtual method from TMessage. Packs data into message buffer and // sets the new message length. void* TMsgDirGetDirContentsReply::Pack(void) { WTRACE("TMsgDirGetDirContentsReply::Pack"); SetServiceType(WONMsg::DirServer); SetMessageType(WONMsg::DirGetDirContentsReply); TMessage::Pack(); WDBG_LL("TMsgDirGetDirContentsReply::Pack Appending message data"); AppendShort(static_cast<short>(mStatus)); AppendShort(mEntries.size()); WDBG_LL("TMsgDirGetDirContentsReply::Pack Appending " << mEntries.size() << "entries."); DirServerEntryVector::iterator anItr = mEntries.begin(); for (; anItr != mEntries.end(); anItr++) PackEntry(*anItr); return GetDataPtr(); }
// SMsgDirG2GetNumEntities::Pack // Virtual method from SmallMessage. Packs data into message buffer. void* SMsgDirG2GetNumEntities::Pack(void) { WTRACE("SMsgDirG2GetNumEntities::Pack"); SetServiceType(WONMsg::SmallDirServerG2); SetMessageType(WONMsg::DirG2GetNumEntities); SmallMessage::Pack(); WDBG_LL("SMsgDirG2GetNumEntities::Pack Appending message data"); AppendShort(mPaths.size()); WDBG_LL("SMsgDirG2GetNumEntities::Pack Writing " << mPaths.size() << " entries."); DirPathList::iterator anItr(mPaths.begin()); for (; anItr != mPaths.end(); anItr++) { Append_PW_STRING(anItr->mPath); AppendShort(static_cast<short>(anItr->mMode)); } return GetDataPtr(); }
// MMsgObsGetDataPoolReply::Pack // Virtual method from MiniMessage. Packs data into message buffer and // sets the new message length. void* MMsgObsGetDataPoolReply::Pack(void) { WTRACE("MMsgObsGetDataPoolReply::Pack"); SetServiceType(WONMsg::MiniObsServer); SetMessageType(WONMsg::ObsMsg_GetDataPoolReply); MiniMessage::Pack(); WDBG_LL("MMsgObsGetDataPoolReply::Pack Appending message data"); AppendShort((short)mStatus); AppendLong(mDataPoolId); AppendShort(mDataLength); if (mDataLength > 0) { AppendBytes(mDataLength, mDataP); } return GetDataPtr(); }
// SMsgDirG2PeerConnectReply::Pack // Virtual method from SmallMessage. Packs data into message buffer and // sets the new message length. void* SMsgDirG2GetNumEntitiesReply::Pack(void) { WTRACE("SMsgDirG2GetNumEntitiesReply::Pack"); SetServiceType(WONMsg::SmallDirServerG2); SetMessageType(WONMsg::DirG2GetNumEntitiesReply); SmallMessage::Pack(); WDBG_LL("SMsgDirG2GetNumEntitiesReply::Pack Appending message data"); AppendShort(mEntries.size()); WDBG_LL("SMsgDirG2GetNumEntitiesReply::Pack Appending " << mEntries.size() << " entries."); NumEntriesList::iterator anItr = mEntries.begin(); for (; anItr != mEntries.end(); anItr++) { AppendShort(anItr->first); AppendShort(anItr->second); } return GetDataPtr(); }
// MMsgObsSubscribeReply::Pack // Virtual method from MiniMessage. Packs data into message buffer and // sets the new message length. void* MMsgObsSubscribeReply::Pack(void) { WTRACE("MMsgObsSubscribeReply::Pack"); SetServiceType(WONMsg::MiniObsServer); SetMessageType(WONMsg::ObsMsg_SubscribeReply); MiniMessage::Pack(); WDBG_LL("MMsgObsSubscribeReply::Pack Appending message data"); AppendShort((short)(mStatus)); AppendLong(mPublicationId); AppendLong(mSubscriberId); AppendShort(mDataLength); if (mDataLength > 0) { AppendBytes(mDataLength, mDataP); } Append_PA_STRING(mPeerRedirection); return GetDataPtr(); }
void* TMsgFactStatusReply::Pack(void){ WTRACE("TMsgFactStatusReply::Pack"); SetServiceType(WONMsg::FactoryServer); SetMessageType(WONMsg::FactStatusReply); TMessage::Pack(); WDBG_LL("TMsgFactStatusReply::Pack Appending message data"); AppendShort(mProcessStatus); AppendByte(mProcessPortIDSet.size()); for(FACT_SERV_PORT_RANGE_SET::iterator aPortIterator(mProcessPortIDSet.begin()); aPortIterator != mProcessPortIDSet.end(); aPortIterator++){ AppendShort(*aPortIterator); } return GetDataPtr(); }
// SMsgCommStatusReply::Pack // Virtual method from SmallMessage. Packs data into message buffer and // sets the new message length. void* SMsgCommStatusReply::Pack(void) { WTRACE("SMsgCommStatusReply::Pack"); SetServiceType(WONMsg::CommonService); SetMessageType(WONMsg::SmallCommStatusReply); SmallMessage::Pack(); WDBG_LL("SMsgCommStatusReply::Pack Appending message data"); AppendShort(static_cast<short>(mStatus)); return GetDataPtr(); }
// TMsgDirSynchDirTree::Pack // Virtual method from TMessage. Packs data into message buffer and // sets the new message length. void* TMsgDirSynchDirTree::Pack(void) { WTRACE("TMsgDirSynchDirTree::Pack"); SetServiceType(WONMsg::DirServer); SetMessageType(WONMsg::DirSynchDirTree); TMessage::Pack(); WDBG_LL("TMsgDirSynchDirTree::Pack Appending message data"); Append_PA_STRING(mServIP); AppendShort(mServPort); return GetDataPtr(); }
// TMsgCommQueryOptReply::Pack // Virtual method from TMessage. Packs data into message buffer and // sets the new message length. void* TMsgCommQueryOptReply::Pack(void) { WTRACE("TMsgCommQueryOptReply::Pack"); SetServiceType(WONMsg::CommonService); SetMessageType(WONMsg::CommQueryOptionsReply); TMessage::Pack(); WDBG_LL("TMsgCommQueryOptReply::Pack Appending " << mOptionMap.size() << " entries"); AppendShort(mOptionMap.size()); OptionMap::iterator anItr = mOptionMap.begin(); for (; anItr != mOptionMap.end(); anItr++) { Append_PA_STRING(anItr->first); AppendByte(anItr->second.first); Append_PW_STRING(anItr->second.second); } AppendShort(static_cast<short>(mStatus)); return GetDataPtr(); }
// MMsgCommMRTGReply::Pack // Virtual method from MiniMessage. Packs data into message buffer and // sets the new message length. void* MMsgCommMRTGReply::Pack(void) { WTRACE("MMsgCommMRTGReply::Pack"); SetServiceType(WONMsg::MiniCommonService); SetMessageType(WONMsg::MiniCommMRTGReply); MiniMessage::Pack(); AppendShort(mStatus); AppendLongLong(mPrimaryData); AppendLongLong(mSecondaryData); return GetDataPtr(); }
void* TMsgCommShutDownConfirmationReply::Pack(void){ WTRACE("TMsgCommShutDownConfirmationReply::Pack"); SetServiceType(WONMsg::CommonService); SetMessageType(WONMsg::CommShutDownConfReply); TMessage::Pack(); WDBG_LL("TMsgCommShutDownConfirmationReply::Pack Appending message data"); AppendShort(mStatus); return GetDataPtr(); }
void* MMsgRoutingStatusReply::Pack(void) { WTRACE("MMsgRoutingStatusReply::Pack"); SetServiceType(WONMsg::MiniRoutingServer); SetMessageType(WONMsg::RoutingStatusReply); RoutingServerMessage::Pack(); WDBG_LL("MMsgRoutingStatusReply::Pack Appending message data"); // append the status AppendShort(mStatus); return GetDataPtr(); }
// TMsgAuth1Challenge1::Pack // Virtual method from TMessage. Packs data into message buffer and // sets the new message length. void* TMsgAuth1Challenge1::Pack(void) { WTRACE("TMsgAuth1Challenge1::Pack"); SetServiceType(WONMsg::Auth1PeerToPeer); SetMessageType(WONMsg::Auth1Challenge1); TMsgAuthRawBufferBase::Pack(); WDBG_LL("TMsgAuth1Challenge1::Pack Appending message data"); AppendShort(mSecretBLen); if (mSecretBLen > 0) AppendBytes(mSecretBLen, mSecretBP); PackRawBuf(); return GetDataPtr(); }
// MMsgObsAddPublisherReply::Pack // Virtual method from MiniMessage. Packs data into message buffer and // sets the new message length. void* MMsgObsAddPublisherReply::Pack(void) { WTRACE("MMsgObsAddPublisherReply::Pack"); SetServiceType(WONMsg::MiniObsServer); SetMessageType(WONMsg::ObsMsg_AddPublisherReply); MiniMessage::Pack(); WDBG_LL("MMsgObsAddPublisherReply::Pack Appending message data"); AppendShort((short)(mStatus)); AppendLong((unsigned long)(mPublisherId)); return GetDataPtr(); }
// MMsgCommGetNumUsers::Pack // Virtual method from MiniMessage. Packs data into message buffer and // sets the new message length. void* MMsgCommGetNumUsers::Pack(void) { WTRACE("MMsgCommGetNumUsers::Pack"); SetServiceType(WONMsg::MiniCommonService); SetMessageType(WONMsg::MiniCommGetNumUsers); MiniMessage::Pack(); // Generate and pack in startTick WDBG_LL("MMsgCommGetNumUsers::Pack Appending message data"); AppendShort(mTag); return GetDataPtr(); }
void* MMsgRoutingGetUserListReply::Pack(void) { WTRACE("MMsgRoutingGetUserListReply::Pack"); SetServiceType(WONMsg::MiniRoutingServer); SetMessageType(WONMsg::RoutingGetUserListReply); RoutingServerMessage::Pack(); WDBG_LL("MMsgRoutingGetUserListReply::Pack Appending message data"); // append the status AppendShort(mStatus); // append the user count _ASSERT(mUserList.size() <= USHRT_MAX); AppendShort(mUserList.size()); // append the user list std::list<UserData>::iterator itr = mUserList.begin(); for ( ; itr != mUserList.end(); itr++) AppendUserName(itr->mUserName); return GetDataPtr(); }
// MMsgObsReestablishPersistentTCP::Pack // Virtual method from MiniMessage. Packs data into message buffer and // sets the new message length. void* MMsgObsReestablishPersistentTCP::Pack(void) { WTRACE("MMsgObsReestablishPersistentTCP::Pack"); SetServiceType(WONMsg::MiniObsServer); SetMessageType(WONMsg::ObsMsg_ReestablishPersistentTCP); MiniMessage::Pack(); WDBG_LL("MMsgObsReestablishPersistentTCP::Pack Appending message data"); AppendLong(mClientId); AppendShort((short)mClientType); return GetDataPtr(); }
// TMsgAuth1Request::Pack // Virtual method from TMessage. Packs data into message buffer and // sets the new message length. void* TMsgAuth1Request::Pack(void) { WTRACE("TMsgAuth1Request::Pack"); SetServiceType(WONMsg::Auth1PeerToPeer); SetMessageType(WONMsg::Auth1Request); TMsgAuthRawBufferBase::Pack(); WDBG_LL("TMsgAuth1Request::Pack Appending message data"); AppendByte(static_cast<unsigned char>(mAuthMode)); AppendByte(static_cast<unsigned char>(mEncryptMode)); AppendShort(mEncryptFlags); PackRawBuf(); return GetDataPtr(); }
// TMsgCommQueryOptions::Pack // Virtual method from TMessage. Packs data into message buffer and // sets the new message length. void* TMsgCommQueryOptions::Pack(void) { WTRACE("TMsgCommQueryOptions::Pack"); SetServiceType(WONMsg::CommonService); SetMessageType(WONMsg::CommQueryOptions); TMessage::Pack(); WDBG_LL("TMsgCommQueryOptions::Pack Appending " << mOptionList.size() << "entries."); AppendShort(mOptionList.size()); OptionList::iterator anItr = mOptionList.begin(); for (; anItr != mOptionList.end(); anItr++) Append_PA_STRING(*anItr); return GetDataPtr(); }
void* MMsgRoutingCreateGroupReply::Pack(void) { WTRACE("MMsgRoutingCreateGroupReply::Pack"); SetServiceType(WONMsg::MiniRoutingServer); SetMessageType(WONMsg::RoutingCreateGroupReply); RoutingServerMessage::Pack(); WDBG_LL("MMsgRoutingCreateGroupReply::Pack Appending message data"); AppendShort(mStatus); if (mStatus == WONMsg::StatusCommon_Success) AppendGroupId(mGroupId); return GetDataPtr(); }