// 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();
}
