836 lines
22 KiB
C++
836 lines
22 KiB
C++
/**
|
|
* @file lltemplatemessagereader.cpp
|
|
* @brief LLTemplateMessageReader class implementation.
|
|
*
|
|
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "linden_common.h"
|
|
#include "lltemplatemessagereader.h"
|
|
|
|
#include "llfasttimer.h"
|
|
#include "llmessagebuilder.h"
|
|
#include "llmessagetemplate.h"
|
|
#include "llmath.h"
|
|
#include "llquaternion.h"
|
|
#include "message.h"
|
|
#include "u64.h"
|
|
#include "v3dmath.h"
|
|
#include "v3math.h"
|
|
#include "v4math.h"
|
|
|
|
LLTemplateMessageReader::LLTemplateMessageReader(message_template_number_map_t&
|
|
number_template_map) :
|
|
mReceiveSize(0),
|
|
mCurrentRMessageTemplate(NULL),
|
|
mCurrentRMessageData(NULL),
|
|
mMessageNumbers(number_template_map)
|
|
{
|
|
}
|
|
|
|
//virtual
|
|
LLTemplateMessageReader::~LLTemplateMessageReader()
|
|
{
|
|
delete mCurrentRMessageData;
|
|
mCurrentRMessageData = NULL;
|
|
}
|
|
|
|
//virtual
|
|
void LLTemplateMessageReader::clearMessage()
|
|
{
|
|
mReceiveSize = -1;
|
|
mCurrentRMessageTemplate = NULL;
|
|
delete mCurrentRMessageData;
|
|
mCurrentRMessageData = NULL;
|
|
}
|
|
|
|
void LLTemplateMessageReader::getData(const char *blockname, const char *varname, void *datap, S32 size, S32 blocknum, S32 max_size)
|
|
{
|
|
// is there a message ready to go?
|
|
if (mReceiveSize == -1)
|
|
{
|
|
llerrs << "No message waiting for decode 2!" << llendl;
|
|
return;
|
|
}
|
|
|
|
if (!mCurrentRMessageData)
|
|
{
|
|
llerrs << "Invalid mCurrentMessageData in getData!" << llendl;
|
|
return;
|
|
}
|
|
|
|
char *bnamep = (char *)blockname + blocknum; // this works because it's just a hash. The bnamep is never derefference
|
|
char *vnamep = (char *)varname;
|
|
|
|
LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
|
|
|
|
if (iter == mCurrentRMessageData->mMemberBlocks.end())
|
|
{
|
|
llerrs << "Block " << blockname << " #" << blocknum
|
|
<< " not in message " << mCurrentRMessageData->mName << llendl;
|
|
return;
|
|
}
|
|
|
|
LLMsgBlkData *msg_block_data = iter->second;
|
|
LLMsgVarData& vardata = msg_block_data->mMemberVarData[vnamep];
|
|
|
|
if (!vardata.getName())
|
|
{
|
|
llerrs << "Variable "<< vnamep << " not in message "
|
|
<< mCurrentRMessageData->mName<< " block " << bnamep << llendl;
|
|
return;
|
|
}
|
|
|
|
if (size && size != vardata.getSize())
|
|
{
|
|
llerrs << "Msg " << mCurrentRMessageData->mName
|
|
<< " variable " << vnamep
|
|
<< " is size " << vardata.getSize()
|
|
<< " but copying into buffer of size " << size
|
|
<< llendl;
|
|
return;
|
|
}
|
|
|
|
|
|
const S32 vardata_size = vardata.getSize();
|
|
if( max_size >= vardata_size )
|
|
{
|
|
switch( vardata_size )
|
|
{
|
|
case 1:
|
|
*((U8*)datap) = *((U8*)vardata.getData());
|
|
break;
|
|
case 2:
|
|
*((U16*)datap) = *((U16*)vardata.getData());
|
|
break;
|
|
case 4:
|
|
*((U32*)datap) = *((U32*)vardata.getData());
|
|
break;
|
|
case 8:
|
|
((U32*)datap)[0] = ((U32*)vardata.getData())[0];
|
|
((U32*)datap)[1] = ((U32*)vardata.getData())[1];
|
|
break;
|
|
default:
|
|
memcpy(datap, vardata.getData(), vardata_size);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
llwarns << "Msg " << mCurrentRMessageData->mName
|
|
<< " variable " << vnamep
|
|
<< " is size " << vardata.getSize()
|
|
<< " but truncated to max size of " << max_size
|
|
<< llendl;
|
|
|
|
memcpy(datap, vardata.getData(), max_size);
|
|
}
|
|
}
|
|
|
|
S32 LLTemplateMessageReader::getNumberOfBlocks(const char *blockname)
|
|
{
|
|
// is there a message ready to go?
|
|
if (mReceiveSize == -1)
|
|
{
|
|
llerrs << "No message waiting for decode 3!" << llendl;
|
|
return -1;
|
|
}
|
|
|
|
if (!mCurrentRMessageData)
|
|
{
|
|
llerrs << "Invalid mCurrentRMessageData in getData!" << llendl;
|
|
return -1;
|
|
}
|
|
|
|
char *bnamep = (char *)blockname;
|
|
|
|
LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
|
|
|
|
if (iter == mCurrentRMessageData->mMemberBlocks.end())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return (iter->second)->mBlockNumber;
|
|
}
|
|
|
|
S32 LLTemplateMessageReader::getSize(const char *blockname, const char *varname)
|
|
{
|
|
// is there a message ready to go?
|
|
if (mReceiveSize == -1)
|
|
{ // This is a serious error - crash
|
|
llerrs << "No message waiting for decode 4!" << llendl;
|
|
return LL_MESSAGE_ERROR;
|
|
}
|
|
|
|
if (!mCurrentRMessageData)
|
|
{ // This is a serious error - crash
|
|
llerrs << "Invalid mCurrentRMessageData in getData!" << llendl;
|
|
return LL_MESSAGE_ERROR;
|
|
}
|
|
|
|
char *bnamep = (char *)blockname;
|
|
|
|
LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
|
|
|
|
if (iter == mCurrentRMessageData->mMemberBlocks.end())
|
|
{ // don't crash
|
|
llinfos << "Block " << bnamep << " not in message "
|
|
<< mCurrentRMessageData->mName << llendl;
|
|
return LL_BLOCK_NOT_IN_MESSAGE;
|
|
}
|
|
|
|
char *vnamep = (char *)varname;
|
|
|
|
LLMsgBlkData* msg_data = iter->second;
|
|
LLMsgVarData& vardata = msg_data->mMemberVarData[vnamep];
|
|
|
|
if (!vardata.getName())
|
|
{ // don't crash
|
|
llinfos << "Variable " << varname << " not in message "
|
|
<< mCurrentRMessageData->mName << " block " << bnamep << llendl;
|
|
return LL_VARIABLE_NOT_IN_BLOCK;
|
|
}
|
|
|
|
if (mCurrentRMessageTemplate->mMemberBlocks[bnamep]->mType != MBT_SINGLE)
|
|
{ // This is a serious error - crash
|
|
llerrs << "Block " << bnamep << " isn't type MBT_SINGLE,"
|
|
" use getSize with blocknum argument!" << llendl;
|
|
return LL_MESSAGE_ERROR;
|
|
}
|
|
|
|
return vardata.getSize();
|
|
}
|
|
|
|
S32 LLTemplateMessageReader::getSize(const char *blockname, S32 blocknum, const char *varname)
|
|
{
|
|
// is there a message ready to go?
|
|
if (mReceiveSize == -1)
|
|
{ // This is a serious error - crash
|
|
llerrs << "No message waiting for decode 5!" << llendl;
|
|
return LL_MESSAGE_ERROR;
|
|
}
|
|
|
|
if (!mCurrentRMessageData)
|
|
{ // This is a serious error - crash
|
|
llerrs << "Invalid mCurrentRMessageData in getData!" << llendl;
|
|
return LL_MESSAGE_ERROR;
|
|
}
|
|
|
|
char *bnamep = (char *)blockname + blocknum;
|
|
char *vnamep = (char *)varname;
|
|
|
|
LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
|
|
|
|
if (iter == mCurrentRMessageData->mMemberBlocks.end())
|
|
{ // don't crash
|
|
llinfos << "Block " << bnamep << " not in message "
|
|
<< mCurrentRMessageData->mName << llendl;
|
|
return LL_BLOCK_NOT_IN_MESSAGE;
|
|
}
|
|
|
|
LLMsgBlkData* msg_data = iter->second;
|
|
LLMsgVarData& vardata = msg_data->mMemberVarData[vnamep];
|
|
|
|
if (!vardata.getName())
|
|
{ // don't crash
|
|
llinfos << "Variable " << vnamep << " not in message "
|
|
<< mCurrentRMessageData->mName << " block " << bnamep << llendl;
|
|
return LL_VARIABLE_NOT_IN_BLOCK;
|
|
}
|
|
|
|
return vardata.getSize();
|
|
}
|
|
|
|
void LLTemplateMessageReader::getBinaryData(const char *blockname,
|
|
const char *varname, void *datap,
|
|
S32 size, S32 blocknum,
|
|
S32 max_size)
|
|
{
|
|
getData(blockname, varname, datap, size, blocknum, max_size);
|
|
}
|
|
|
|
void LLTemplateMessageReader::getS8(const char *block, const char *var,
|
|
S8 &u, S32 blocknum)
|
|
{
|
|
getData(block, var, &u, sizeof(S8), blocknum);
|
|
}
|
|
|
|
void LLTemplateMessageReader::getU8(const char *block, const char *var,
|
|
U8 &u, S32 blocknum)
|
|
{
|
|
getData(block, var, &u, sizeof(U8), blocknum);
|
|
}
|
|
|
|
void LLTemplateMessageReader::getBOOL(const char *block, const char *var,
|
|
BOOL &b, S32 blocknum )
|
|
{
|
|
U8 value;
|
|
getData(block, var, &value, sizeof(U8), blocknum);
|
|
b = (BOOL) value;
|
|
}
|
|
|
|
void LLTemplateMessageReader::getS16(const char *block, const char *var,
|
|
S16 &d, S32 blocknum)
|
|
{
|
|
getData(block, var, &d, sizeof(S16), blocknum);
|
|
}
|
|
|
|
void LLTemplateMessageReader::getU16(const char *block, const char *var,
|
|
U16 &d, S32 blocknum)
|
|
{
|
|
getData(block, var, &d, sizeof(U16), blocknum);
|
|
}
|
|
|
|
void LLTemplateMessageReader::getS32(const char *block, const char *var,
|
|
S32 &d, S32 blocknum)
|
|
{
|
|
getData(block, var, &d, sizeof(S32), blocknum);
|
|
}
|
|
|
|
void LLTemplateMessageReader::getU32(const char *block, const char *var,
|
|
U32 &d, S32 blocknum)
|
|
{
|
|
getData(block, var, &d, sizeof(U32), blocknum);
|
|
}
|
|
|
|
void LLTemplateMessageReader::getU64(const char *block, const char *var,
|
|
U64 &d, S32 blocknum)
|
|
{
|
|
getData(block, var, &d, sizeof(U64), blocknum);
|
|
}
|
|
|
|
void LLTemplateMessageReader::getF32(const char *block, const char *var,
|
|
F32 &d, S32 blocknum)
|
|
{
|
|
getData(block, var, &d, sizeof(F32), blocknum);
|
|
|
|
if( !llfinite( d ) )
|
|
{
|
|
llwarns << "non-finite in getF32Fast " << block << " " << var
|
|
<< llendl;
|
|
d = 0;
|
|
}
|
|
}
|
|
|
|
void LLTemplateMessageReader::getF64(const char *block, const char *var,
|
|
F64 &d, S32 blocknum)
|
|
{
|
|
getData(block, var, &d, sizeof(F64), blocknum);
|
|
|
|
if( !llfinite( d ) )
|
|
{
|
|
llwarns << "non-finite in getF64Fast " << block << " " << var
|
|
<< llendl;
|
|
d = 0;
|
|
}
|
|
}
|
|
|
|
void LLTemplateMessageReader::getVector3(const char *block, const char *var,
|
|
LLVector3 &v, S32 blocknum )
|
|
{
|
|
getData(block, var, &v.mV[0], sizeof(v.mV), blocknum);
|
|
|
|
if( !v.isFinite() )
|
|
{
|
|
llwarns << "non-finite in getVector3Fast " << block << " "
|
|
<< var << llendl;
|
|
v.zeroVec();
|
|
}
|
|
}
|
|
|
|
void LLTemplateMessageReader::getVector4(const char *block, const char *var,
|
|
LLVector4 &v, S32 blocknum)
|
|
{
|
|
getData(block, var, &v.mV[0], sizeof(v.mV), blocknum);
|
|
|
|
if( !v.isFinite() )
|
|
{
|
|
llwarns << "non-finite in getVector4Fast " << block << " "
|
|
<< var << llendl;
|
|
v.zeroVec();
|
|
}
|
|
}
|
|
|
|
void LLTemplateMessageReader::getVector3d(const char *block, const char *var,
|
|
LLVector3d &v, S32 blocknum )
|
|
{
|
|
getData(block, var, &v.mdV[0], sizeof(v.mdV), blocknum);
|
|
|
|
if( !v.isFinite() )
|
|
{
|
|
llwarns << "non-finite in getVector3dFast " << block << " "
|
|
<< var << llendl;
|
|
v.zeroVec();
|
|
}
|
|
|
|
}
|
|
|
|
void LLTemplateMessageReader::getQuat(const char *block, const char *var,
|
|
LLQuaternion &q, S32 blocknum)
|
|
{
|
|
LLVector3 vec;
|
|
getData(block, var, &vec.mV[0], sizeof(vec.mV), blocknum);
|
|
if( vec.isFinite() )
|
|
{
|
|
q.unpackFromVector3( vec );
|
|
}
|
|
else
|
|
{
|
|
llwarns << "non-finite in getQuatFast " << block << " " << var
|
|
<< llendl;
|
|
q.loadIdentity();
|
|
}
|
|
}
|
|
|
|
void LLTemplateMessageReader::getUUID(const char *block, const char *var,
|
|
LLUUID &u, S32 blocknum)
|
|
{
|
|
getData(block, var, &u.mData[0], sizeof(u.mData), blocknum);
|
|
}
|
|
|
|
inline void LLTemplateMessageReader::getIPAddr(const char *block, const char *var, U32 &u, S32 blocknum)
|
|
{
|
|
getData(block, var, &u, sizeof(U32), blocknum);
|
|
}
|
|
|
|
inline void LLTemplateMessageReader::getIPPort(const char *block, const char *var, U16 &u, S32 blocknum)
|
|
{
|
|
getData(block, var, &u, sizeof(U16), blocknum);
|
|
u = ntohs(u);
|
|
}
|
|
|
|
inline void LLTemplateMessageReader::getString(const char *block, const char *var, S32 buffer_size, char *s, S32 blocknum )
|
|
{
|
|
s[0] = '\0';
|
|
getData(block, var, s, 0, blocknum, buffer_size);
|
|
s[buffer_size - 1] = '\0';
|
|
}
|
|
|
|
inline void LLTemplateMessageReader::getString(const char *block, const char *var, std::string& outstr, S32 blocknum )
|
|
{
|
|
char s[MTUBYTES + 1]= {0}; // every element is initialized with 0
|
|
getData(block, var, s, 0, blocknum, MTUBYTES);
|
|
s[MTUBYTES] = '\0';
|
|
outstr = s;
|
|
}
|
|
|
|
//virtual
|
|
S32 LLTemplateMessageReader::getMessageSize() const
|
|
{
|
|
return mReceiveSize;
|
|
}
|
|
|
|
// Returns template for the message contained in buffer
|
|
BOOL LLTemplateMessageReader::decodeTemplate(
|
|
const U8* buffer, S32 buffer_size, // inputs
|
|
LLMessageTemplate** msg_template, bool custom ) // outputs
|
|
{
|
|
const U8* header = buffer + LL_PACKET_ID_SIZE;
|
|
|
|
// is there a message ready to go?
|
|
if (buffer_size <= 0)
|
|
{
|
|
llwarns << "No message waiting for decode!" << llendl;
|
|
return(FALSE);
|
|
}
|
|
|
|
U32 num = 0;
|
|
|
|
if (header[0] != 255)
|
|
{
|
|
// high frequency message
|
|
num = header[0];
|
|
}
|
|
else if ((buffer_size >= ((S32) LL_MINIMUM_VALID_PACKET_SIZE + 1)) && (header[1] != 255))
|
|
{
|
|
// medium frequency message
|
|
num = (255 << 8) | header[1];
|
|
}
|
|
else if ((buffer_size >= ((S32) LL_MINIMUM_VALID_PACKET_SIZE + 3)) && (header[1] == 255))
|
|
{
|
|
// low frequency message
|
|
U16 message_id_U16 = 0;
|
|
// I think this check busts the message system.
|
|
// it appears that if there is a NULL in the message #, it won't copy it....
|
|
// what was the goal?
|
|
//if(header[2])
|
|
memcpy(&message_id_U16, &header[2], 2);
|
|
|
|
// dependant on endian-ness:
|
|
// U32 temp = (255 << 24) | (255 << 16) | header[2];
|
|
|
|
// independant of endian-ness:
|
|
message_id_U16 = ntohs(message_id_U16);
|
|
num = 0xFFFF0000 | message_id_U16;
|
|
}
|
|
else // bogus packet received (too short)
|
|
{
|
|
if(!custom)
|
|
llwarns << "Packet with unusable length received (too short): "
|
|
<< buffer_size << llendl;
|
|
return(FALSE);
|
|
}
|
|
|
|
LLMessageTemplate* temp = get_ptr_in_map(mMessageNumbers,num);
|
|
if (temp)
|
|
{
|
|
*msg_template = temp;
|
|
}
|
|
else
|
|
{
|
|
if(!custom) {
|
|
llwarns << "Message #" << std::hex << num << std::dec
|
|
<< " received but not registered!" << llendl;
|
|
gMessageSystem->callExceptionFunc(MX_UNREGISTERED_MESSAGE);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void LLTemplateMessageReader::logRanOffEndOfPacket( const LLHost& host, const S32 where, const S32 wanted )
|
|
{
|
|
// we've run off the end of the packet!
|
|
llwarns << "Ran off end of packet " << mCurrentRMessageTemplate->mName
|
|
// << " with id " << mCurrentRecvPacketID
|
|
<< " from " << host
|
|
<< " trying to read " << wanted
|
|
<< " bytes at position " << where
|
|
<< " going past packet end at " << mReceiveSize
|
|
<< llendl;
|
|
if(gMessageSystem->mVerboseLog)
|
|
{
|
|
llinfos << "MSG: -> " << host << "\tREAD PAST END:\t"
|
|
// << mCurrentRecvPacketID << " "
|
|
<< getMessageName() << llendl;
|
|
}
|
|
gMessageSystem->callExceptionFunc(MX_RAN_OFF_END_OF_PACKET);
|
|
}
|
|
|
|
static LLFastTimer::DeclareTimer FTM_PROCESS_MESSAGES("Process Messages");
|
|
|
|
// decode a given message
|
|
BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender, bool custom)
|
|
{
|
|
llassert( mReceiveSize >= 0 );
|
|
llassert( mCurrentRMessageTemplate);
|
|
llassert( !mCurrentRMessageData );
|
|
delete mCurrentRMessageData; // just to make sure
|
|
|
|
// The offset tells us how may bytes to skip after the end of the
|
|
// message name.
|
|
U8 offset = buffer[PHL_OFFSET];
|
|
S32 decode_pos = LL_PACKET_ID_SIZE + (S32)(mCurrentRMessageTemplate->mFrequency) + offset;
|
|
|
|
// create base working data set
|
|
mCurrentRMessageData = new LLMsgData(mCurrentRMessageTemplate->mName);
|
|
|
|
// loop through the template building the data structure as we go
|
|
LLMessageTemplate::message_block_map_t::const_iterator iter;
|
|
for(iter = mCurrentRMessageTemplate->mMemberBlocks.begin();
|
|
iter != mCurrentRMessageTemplate->mMemberBlocks.end();
|
|
++iter)
|
|
{
|
|
LLMessageBlock* mbci = *iter;
|
|
U8 repeat_number;
|
|
S32 i;
|
|
|
|
// how many of this block?
|
|
|
|
if (mbci->mType == MBT_SINGLE)
|
|
{
|
|
// just one
|
|
repeat_number = 1;
|
|
}
|
|
else if (mbci->mType == MBT_MULTIPLE)
|
|
{
|
|
// a known number
|
|
repeat_number = mbci->mNumber;
|
|
}
|
|
else if (mbci->mType == MBT_VARIABLE)
|
|
{
|
|
// need to read the number from the message
|
|
// repeat number is a single byte
|
|
if (decode_pos >= mReceiveSize)
|
|
{
|
|
// commented out - hetgrid says that missing variable blocks
|
|
// at end of message are legal
|
|
// logRanOffEndOfPacket(sender, decode_pos, 1);
|
|
|
|
// default to 0 repeats
|
|
repeat_number = 0;
|
|
}
|
|
else
|
|
{
|
|
repeat_number = buffer[decode_pos];
|
|
decode_pos++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!custom)
|
|
llerrs << "Unknown block type" << llendl;
|
|
return FALSE;
|
|
}
|
|
|
|
LLMsgBlkData* cur_data_block = NULL;
|
|
|
|
// now loop through the block
|
|
for (i = 0; i < repeat_number; i++)
|
|
{
|
|
if (i)
|
|
{
|
|
// build new name to prevent collisions
|
|
// TODO: This should really change to a vector
|
|
cur_data_block = new LLMsgBlkData(mbci->mName, repeat_number);
|
|
cur_data_block->mName = mbci->mName + i;
|
|
}
|
|
else
|
|
{
|
|
cur_data_block = new LLMsgBlkData(mbci->mName, repeat_number);
|
|
}
|
|
|
|
// add the block to the message
|
|
mCurrentRMessageData->addBlock(cur_data_block);
|
|
|
|
// now read the variables
|
|
for (LLMessageBlock::message_variable_map_t::const_iterator iter =
|
|
mbci->mMemberVariables.begin();
|
|
iter != mbci->mMemberVariables.end(); iter++)
|
|
{
|
|
const LLMessageVariable& mvci = **iter;
|
|
|
|
// ok, build out the variables
|
|
// add variable block
|
|
cur_data_block->addVariable(mvci.getName(), mvci.getType());
|
|
|
|
// what type of variable?
|
|
if (mvci.getType() == MVT_VARIABLE)
|
|
{
|
|
// variable, get the number of bytes to read from the template
|
|
S32 data_size = mvci.getSize();
|
|
U8 tsizeb = 0;
|
|
U16 tsizeh = 0;
|
|
U32 tsize = 0;
|
|
|
|
if ((decode_pos + data_size) > mReceiveSize)
|
|
{
|
|
if (!custom)
|
|
logRanOffEndOfPacket(sender, decode_pos, data_size);
|
|
|
|
// default to 0 length variable blocks
|
|
tsize = 0;
|
|
}
|
|
else
|
|
{
|
|
switch(data_size)
|
|
{
|
|
case 1:
|
|
htonmemcpy(&tsizeb, &buffer[decode_pos], MVT_U8, 1);
|
|
tsize = tsizeb;
|
|
break;
|
|
case 2:
|
|
htonmemcpy(&tsizeh, &buffer[decode_pos], MVT_U16, 2);
|
|
tsize = tsizeh;
|
|
break;
|
|
case 4:
|
|
htonmemcpy(&tsize, &buffer[decode_pos], MVT_U32, 4);
|
|
break;
|
|
default:
|
|
llerrs << "Attempting to read variable field with unknown size of " << data_size << llendl;
|
|
break;
|
|
}
|
|
}
|
|
decode_pos += data_size;
|
|
|
|
cur_data_block->addData(mvci.getName(), &buffer[decode_pos], tsize, mvci.getType());
|
|
decode_pos += tsize;
|
|
}
|
|
else
|
|
{
|
|
// fixed!
|
|
// so, copy data pointer and set data size to fixed size
|
|
if ((decode_pos + mvci.getSize()) > mReceiveSize)
|
|
{
|
|
if(!custom)
|
|
logRanOffEndOfPacket(sender, decode_pos, mvci.getSize());
|
|
|
|
// default to 0s.
|
|
U32 size = mvci.getSize();
|
|
std::vector<U8> data(size, 0);
|
|
cur_data_block->addData(mvci.getName(), &(data[0]),
|
|
size, mvci.getType());
|
|
}
|
|
else
|
|
{
|
|
cur_data_block->addData(mvci.getName(),
|
|
&buffer[decode_pos],
|
|
mvci.getSize(),
|
|
mvci.getType());
|
|
}
|
|
decode_pos += mvci.getSize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mCurrentRMessageData->mMemberBlocks.empty()
|
|
&& !mCurrentRMessageTemplate->mMemberBlocks.empty())
|
|
{
|
|
lldebugs << "Empty message '" << mCurrentRMessageTemplate->mName << "' (no blocks)" << llendl;
|
|
return FALSE;
|
|
}
|
|
|
|
if(!custom)
|
|
{
|
|
static LLTimer decode_timer;
|
|
|
|
if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback())
|
|
{
|
|
decode_timer.reset();
|
|
}
|
|
|
|
{
|
|
LLFastTimer t(FTM_PROCESS_MESSAGES);
|
|
if( !mCurrentRMessageTemplate->callHandlerFunc(gMessageSystem) )
|
|
{
|
|
llwarns << "Message from " << sender << " with no handler function received: " << mCurrentRMessageTemplate->mName << llendl;
|
|
}
|
|
}
|
|
|
|
if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback())
|
|
{
|
|
F32 decode_time = decode_timer.getElapsedTimeF32();
|
|
|
|
if (gMessageSystem->getTimingCallback())
|
|
{
|
|
(gMessageSystem->getTimingCallback())(mCurrentRMessageTemplate->mName,
|
|
decode_time,
|
|
gMessageSystem->getTimingCallbackData());
|
|
}
|
|
|
|
if (LLMessageReader::getTimeDecodes())
|
|
{
|
|
mCurrentRMessageTemplate->mDecodeTimeThisFrame += decode_time;
|
|
|
|
mCurrentRMessageTemplate->mTotalDecoded++;
|
|
mCurrentRMessageTemplate->mTotalDecodeTime += decode_time;
|
|
|
|
if( mCurrentRMessageTemplate->mMaxDecodeTimePerMsg < decode_time )
|
|
{
|
|
mCurrentRMessageTemplate->mMaxDecodeTimePerMsg = decode_time;
|
|
}
|
|
|
|
|
|
if(decode_time > LLMessageReader::getTimeDecodesSpamThreshold())
|
|
{
|
|
lldebugs << "--------- Message " << mCurrentRMessageTemplate->mName << " decode took " << decode_time << " seconds. (" <<
|
|
mCurrentRMessageTemplate->mMaxDecodeTimePerMsg << " max, " <<
|
|
(mCurrentRMessageTemplate->mTotalDecodeTime / mCurrentRMessageTemplate->mTotalDecoded) << " avg)" << llendl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL LLTemplateMessageReader::validateMessage(const U8* buffer,
|
|
S32 buffer_size,
|
|
const LLHost& sender,
|
|
bool trusted, bool custom)
|
|
{
|
|
mReceiveSize = buffer_size;
|
|
BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate, custom);
|
|
if(valid && !custom)
|
|
{
|
|
mCurrentRMessageTemplate->mReceiveCount++;
|
|
//lldebugs << "MessageRecvd:"
|
|
// << mCurrentRMessageTemplate->mName
|
|
// << " from " << sender << llendl;
|
|
}
|
|
|
|
if (valid && isBanned(trusted))
|
|
{
|
|
LL_WARNS("Messaging") << "LLMessageSystem::checkMessages "
|
|
<< "received banned message "
|
|
<< getMessageName()
|
|
<< " from "
|
|
<< ((trusted) ? "trusted " : "untrusted ")
|
|
<< sender << llendl;
|
|
valid = FALSE;
|
|
}
|
|
|
|
if(valid && isUdpBanned())
|
|
{
|
|
llwarns << "Received UDP black listed message "
|
|
<< getMessageName()
|
|
<< " from " << sender << llendl;
|
|
valid = FALSE;
|
|
}
|
|
return valid;
|
|
}
|
|
|
|
BOOL LLTemplateMessageReader::readMessage(const U8* buffer,
|
|
const LLHost& sender)
|
|
{
|
|
return decodeData(buffer, sender, false);
|
|
}
|
|
|
|
//virtual
|
|
const char* LLTemplateMessageReader::getMessageName() const
|
|
{
|
|
if (!mCurrentRMessageTemplate)
|
|
{
|
|
// no message currently being read
|
|
return "";
|
|
}
|
|
return mCurrentRMessageTemplate->mName;
|
|
}
|
|
|
|
//virtual
|
|
bool LLTemplateMessageReader::isTrusted() const
|
|
{
|
|
return mCurrentRMessageTemplate->getTrust() == MT_TRUST;
|
|
}
|
|
|
|
bool LLTemplateMessageReader::isBanned(bool trustedSource) const
|
|
{
|
|
return mCurrentRMessageTemplate->isBanned(trustedSource);
|
|
}
|
|
|
|
bool LLTemplateMessageReader::isUdpBanned() const
|
|
{
|
|
return mCurrentRMessageTemplate->isUdpBanned();
|
|
}
|
|
|
|
//virtual
|
|
void LLTemplateMessageReader::copyToBuilder(LLMessageBuilder& builder) const
|
|
{
|
|
if(NULL == mCurrentRMessageTemplate)
|
|
{
|
|
return;
|
|
}
|
|
builder.copyFromMessageData(*mCurrentRMessageData);
|
|
}
|