Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 830 insertions, 830 deletions

diff --git a/indra/llmessage/lltemplatemessagereader.cpp b/indra/llmessage/lltemplatemessagereader.cpp
index 064c6e5bd4..46123f0f55 100644
--- a/indra/llmessage/lltemplatemessagereader.cpp
+++ b/indra/llmessage/lltemplatemessagereader.cpp
@@ -1,830 +1,830 @@
-/** 
- * @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)
-	{
-		LL_ERRS() << "No message waiting for decode 2!" << LL_ENDL;
-		return;
-	}
-
-	if (!mCurrentRMessageData)
-	{
-		LL_ERRS() << "Invalid mCurrentMessageData in getData!" << LL_ENDL;
-		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())
-	{
-		LL_ERRS() << "Block " << blockname << " #" << blocknum
-			<< " not in message " << mCurrentRMessageData->mName << LL_ENDL;
-		return;
-	}
-
-	LLMsgBlkData *msg_block_data = iter->second;
-	LLMsgBlkData::msg_var_data_map_t &var_data_map = msg_block_data->mMemberVarData;
-
-	if (var_data_map.find(vnamep) == var_data_map.end())
-	{
-		LL_ERRS() << "Variable "<< vnamep << " not in message "
-			<< mCurrentRMessageData->mName<< " block " << bnamep << LL_ENDL;
-		return;
-	}
-
-	LLMsgVarData& vardata = msg_block_data->mMemberVarData[vnamep];
-
-	if (size && size != vardata.getSize())
-	{
-		LL_ERRS() << "Msg " << mCurrentRMessageData->mName 
-			<< " variable " << vnamep
-			<< " is size " << vardata.getSize()
-			<< " but copying into buffer of size " << size
-			<< LL_ENDL;
-		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
-	{
-		LL_WARNS() << "Msg " << mCurrentRMessageData->mName 
-			<< " variable " << vnamep
-			<< " is size " << vardata.getSize()
-			<< " but truncated to max size of " << max_size
-			<< LL_ENDL;
-
-		memcpy(datap, vardata.getData(), max_size);
-	}
-}
-
-S32 LLTemplateMessageReader::getNumberOfBlocks(const char *blockname)
-{
-	// is there a message ready to go?
-	if (mReceiveSize == -1)
-	{
-		LL_ERRS() << "No message waiting for decode 3!" << LL_ENDL;
-		return -1;
-	}
-
-	if (!mCurrentRMessageData)
-	{
-		LL_ERRS() << "Invalid mCurrentRMessageData in getData!" << LL_ENDL;
-		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 
-		LL_ERRS() << "No message waiting for decode 4!" << LL_ENDL;
-		return LL_MESSAGE_ERROR;
-	}
-
-	if (!mCurrentRMessageData)
-	{	// This is a serious error - crash
-		LL_ERRS() << "Invalid mCurrentRMessageData in getData!" << LL_ENDL;
-		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
-		LL_INFOS() << "Block " << bnamep << " not in message "
-			<< mCurrentRMessageData->mName << LL_ENDL;
-		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
-		LL_INFOS() << "Variable " << varname << " not in message "
-			<< mCurrentRMessageData->mName << " block " << bnamep << LL_ENDL;
-		return LL_VARIABLE_NOT_IN_BLOCK;
-	}
-
-	if (mCurrentRMessageTemplate->mMemberBlocks[bnamep]->mType != MBT_SINGLE)
-	{	// This is a serious error - crash
-		LL_ERRS() << "Block " << bnamep << " isn't type MBT_SINGLE,"
-			" use getSize with blocknum argument!" << LL_ENDL;
-		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
-		LL_ERRS() << "No message waiting for decode 5!" << LL_ENDL;
-		return LL_MESSAGE_ERROR;
-	}
-
-	if (!mCurrentRMessageData)
-	{	// This is a serious error - crash
-		LL_ERRS() << "Invalid mCurrentRMessageData in getData!" << LL_ENDL;
-		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
-		LL_INFOS() << "Block " << bnamep << " not in message " 
-			<< mCurrentRMessageData->mName << LL_ENDL;
-		return LL_BLOCK_NOT_IN_MESSAGE;
-	}
-
-	LLMsgBlkData* msg_data = iter->second;
-	LLMsgVarData& vardata = msg_data->mMemberVarData[vnamep];
-	
-	if (!vardata.getName())
-	{	// don't crash
-		LL_INFOS() << "Variable " << vnamep << " not in message "
-			<<  mCurrentRMessageData->mName << " block " << bnamep << LL_ENDL;
-		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 ) )
-	{
-		LL_WARNS() << "non-finite in getF32Fast " << block << " " << var 
-				<< LL_ENDL;
-		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 ) )
-	{
-		LL_WARNS() << "non-finite in getF64Fast " << block << " " << var 
-				<< LL_ENDL;
-		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() )
-	{
-		LL_WARNS() << "non-finite in getVector3Fast " << block << " " 
-				<< var << LL_ENDL;
-		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() )
-	{
-		LL_WARNS() << "non-finite in getVector4Fast " << block << " " 
-				<< var << LL_ENDL;
-		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() )
-	{
-		LL_WARNS() << "non-finite in getVector3dFast " << block << " " 
-				<< var << LL_ENDL;
-		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
-	{
-		LL_WARNS() << "non-finite in getQuatFast " << block << " " << var 
-				<< LL_ENDL;
-		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 ) // outputs
-{
-	const U8* header = buffer + LL_PACKET_ID_SIZE;
-
-	// is there a message ready to go?
-	if (buffer_size <= 0)
-	{
-		LL_WARNS() << "No message waiting for decode!" << LL_ENDL;
-		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)
-	{
-		LL_WARNS() << "Packet with unusable length received (too short): "
-				<< buffer_size << LL_ENDL;
-		return(false);
-	}
-
-	LLMessageTemplate* temp = get_ptr_in_map(mMessageNumbers,num);
-	if (temp)
-	{
-		*msg_template = temp;
-	}
-	else
-	{
-        // MAINT-7482 - make viewer more tolerant of unknown messages.
-		LL_WARNS_ONCE() << "Message #" << std::hex << num << std::dec
-                        << " received but not registered!" << LL_ENDL;
-		//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!
-	LL_WARNS() << "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
-			<< LL_ENDL;
-	if(gMessageSystem->mVerboseLog)
-	{
-		LL_INFOS() << "MSG: -> " << host << "\tREAD PAST END:\t"
-//				<< mCurrentRecvPacketID << " "
-				<< getMessageName() << LL_ENDL;
-	}
-	gMessageSystem->callExceptionFunc(MX_RAN_OFF_END_OF_PACKET);
-}
-
-static LLTrace::BlockTimerStatHandle FTM_PROCESS_MESSAGES("Process Messages");
-
-// decode a given message
-bool LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender )
-{
-    LL_RECORD_BLOCK_TIME(FTM_PROCESS_MESSAGES);
-
-	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
-		{
-			LL_ERRS() << "Unknown block type" << LL_ENDL;
-			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)
-					{
-						logRanOffEndOfPacket(sender, decode_pos, data_size);
-
-						// default to 0 length variable blocks
-						tsize = 0;
-					}
-					else
-					{
-						switch(data_size)
-						{
-						case 1:
-							htolememcpy(&tsizeb, &buffer[decode_pos], MVT_U8, 1);
-							tsize = tsizeb;
-							break;
-						case 2:
-							htolememcpy(&tsizeh, &buffer[decode_pos], MVT_U16, 2);
-							tsize = tsizeh;
-							break;
-						case 4:
-							htolememcpy(&tsize, &buffer[decode_pos], MVT_U32, 4);
-							break;
-						default:
-							LL_ERRS() << "Attempting to read variable field with unknown size of " << data_size << LL_ENDL;
-							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)
-					{
-						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())
-	{
-		LL_DEBUGS() << "Empty message '" << mCurrentRMessageTemplate->mName << "' (no blocks)" << LL_ENDL;
-		return false;
-	}
-
-	{
-		static LLTimer decode_timer;
-
-		if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback())
-		{
-			decode_timer.reset();
-		}
-
-		if( !mCurrentRMessageTemplate->callHandlerFunc(gMessageSystem) )
-		{
-			LL_WARNS() << "Message from " << sender << " with no handler function received: " << mCurrentRMessageTemplate->mName << LL_ENDL;
-		}
-
-		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())
-				{
-					LL_DEBUGS() << "--------- Message " << mCurrentRMessageTemplate->mName << " decode took " << decode_time << " seconds. (" <<
-						mCurrentRMessageTemplate->mMaxDecodeTimePerMsg << " max, " <<
-						(mCurrentRMessageTemplate->mTotalDecodeTime / mCurrentRMessageTemplate->mTotalDecoded) << " avg)" << LL_ENDL;
-				}
-			}
-		}
-	}
-	return true;
-}
-
-bool LLTemplateMessageReader::validateMessage(const U8* buffer,
-											  S32 buffer_size,
-											  const LLHost& sender,
-											  bool trusted)
-{
-	mReceiveSize = buffer_size;
-	bool valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate );
-	if(valid)
-	{
-		mCurrentRMessageTemplate->mReceiveCount++;
-		//LL_DEBUGS() << "MessageRecvd:"
-		//						 << mCurrentRMessageTemplate->mName 
-		//						 << " from " << sender << LL_ENDL;
-	}
-
-	if (valid && isBanned(trusted))
-	{
-		LL_WARNS("Messaging") << "LLMessageSystem::checkMessages "
-			<< "received banned message "
-			<< getMessageName()
-			<< " from "
-			<< ((trusted) ? "trusted " : "untrusted ")
-			<< sender << LL_ENDL;
-		valid = false;
-	}
-
-	if(valid && isUdpBanned())
-	{
-		LL_WARNS() << "Received UDP black listed message "
-				<<  getMessageName()
-				<< " from " << sender << LL_ENDL;
-		valid = false;
-	}
-	return valid;
-}
-
-bool LLTemplateMessageReader::readMessage(const U8* buffer,
-										  const LLHost& sender)
-{
-	return decodeData(buffer, sender);
-}
-
-//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);
-}
+/**

+ * @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)

+    {

+        LL_ERRS() << "No message waiting for decode 2!" << LL_ENDL;

+        return;

+    }

+

+    if (!mCurrentRMessageData)

+    {

+        LL_ERRS() << "Invalid mCurrentMessageData in getData!" << LL_ENDL;

+        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())

+    {

+        LL_ERRS() << "Block " << blockname << " #" << blocknum

+            << " not in message " << mCurrentRMessageData->mName << LL_ENDL;

+        return;

+    }

+

+    LLMsgBlkData *msg_block_data = iter->second;

+    LLMsgBlkData::msg_var_data_map_t &var_data_map = msg_block_data->mMemberVarData;

+

+    if (var_data_map.find(vnamep) == var_data_map.end())

+    {

+        LL_ERRS() << "Variable "<< vnamep << " not in message "

+            << mCurrentRMessageData->mName<< " block " << bnamep << LL_ENDL;

+        return;

+    }

+

+    LLMsgVarData& vardata = msg_block_data->mMemberVarData[vnamep];

+

+    if (size && size != vardata.getSize())

+    {

+        LL_ERRS() << "Msg " << mCurrentRMessageData->mName

+            << " variable " << vnamep

+            << " is size " << vardata.getSize()

+            << " but copying into buffer of size " << size

+            << LL_ENDL;

+        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

+    {

+        LL_WARNS() << "Msg " << mCurrentRMessageData->mName

+            << " variable " << vnamep

+            << " is size " << vardata.getSize()

+            << " but truncated to max size of " << max_size

+            << LL_ENDL;

+

+        memcpy(datap, vardata.getData(), max_size);

+    }

+}

+

+S32 LLTemplateMessageReader::getNumberOfBlocks(const char *blockname)

+{

+    // is there a message ready to go?

+    if (mReceiveSize == -1)

+    {

+        LL_ERRS() << "No message waiting for decode 3!" << LL_ENDL;

+        return -1;

+    }

+

+    if (!mCurrentRMessageData)

+    {

+        LL_ERRS() << "Invalid mCurrentRMessageData in getData!" << LL_ENDL;

+        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

+        LL_ERRS() << "No message waiting for decode 4!" << LL_ENDL;

+        return LL_MESSAGE_ERROR;

+    }

+

+    if (!mCurrentRMessageData)

+    {   // This is a serious error - crash

+        LL_ERRS() << "Invalid mCurrentRMessageData in getData!" << LL_ENDL;

+        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

+        LL_INFOS() << "Block " << bnamep << " not in message "

+            << mCurrentRMessageData->mName << LL_ENDL;

+        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

+        LL_INFOS() << "Variable " << varname << " not in message "

+            << mCurrentRMessageData->mName << " block " << bnamep << LL_ENDL;

+        return LL_VARIABLE_NOT_IN_BLOCK;

+    }

+

+    if (mCurrentRMessageTemplate->mMemberBlocks[bnamep]->mType != MBT_SINGLE)

+    {   // This is a serious error - crash

+        LL_ERRS() << "Block " << bnamep << " isn't type MBT_SINGLE,"

+            " use getSize with blocknum argument!" << LL_ENDL;

+        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

+        LL_ERRS() << "No message waiting for decode 5!" << LL_ENDL;

+        return LL_MESSAGE_ERROR;

+    }

+

+    if (!mCurrentRMessageData)

+    {   // This is a serious error - crash

+        LL_ERRS() << "Invalid mCurrentRMessageData in getData!" << LL_ENDL;

+        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

+        LL_INFOS() << "Block " << bnamep << " not in message "

+            << mCurrentRMessageData->mName << LL_ENDL;

+        return LL_BLOCK_NOT_IN_MESSAGE;

+    }

+

+    LLMsgBlkData* msg_data = iter->second;

+    LLMsgVarData& vardata = msg_data->mMemberVarData[vnamep];

+

+    if (!vardata.getName())

+    {   // don't crash

+        LL_INFOS() << "Variable " << vnamep << " not in message "

+            <<  mCurrentRMessageData->mName << " block " << bnamep << LL_ENDL;

+        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 ) )

+    {

+        LL_WARNS() << "non-finite in getF32Fast " << block << " " << var

+                << LL_ENDL;

+        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 ) )

+    {

+        LL_WARNS() << "non-finite in getF64Fast " << block << " " << var

+                << LL_ENDL;

+        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() )

+    {

+        LL_WARNS() << "non-finite in getVector3Fast " << block << " "

+                << var << LL_ENDL;

+        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() )

+    {

+        LL_WARNS() << "non-finite in getVector4Fast " << block << " "

+                << var << LL_ENDL;

+        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() )

+    {

+        LL_WARNS() << "non-finite in getVector3dFast " << block << " "

+                << var << LL_ENDL;

+        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

+    {

+        LL_WARNS() << "non-finite in getQuatFast " << block << " " << var

+                << LL_ENDL;

+        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 ) // outputs

+{

+    const U8* header = buffer + LL_PACKET_ID_SIZE;

+

+    // is there a message ready to go?

+    if (buffer_size <= 0)

+    {

+        LL_WARNS() << "No message waiting for decode!" << LL_ENDL;

+        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)

+    {

+        LL_WARNS() << "Packet with unusable length received (too short): "

+                << buffer_size << LL_ENDL;

+        return(false);

+    }

+

+    LLMessageTemplate* temp = get_ptr_in_map(mMessageNumbers,num);

+    if (temp)

+    {

+        *msg_template = temp;

+    }

+    else

+    {

+        // MAINT-7482 - make viewer more tolerant of unknown messages.

+        LL_WARNS_ONCE() << "Message #" << std::hex << num << std::dec

+                        << " received but not registered!" << LL_ENDL;

+        //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!

+    LL_WARNS() << "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

+            << LL_ENDL;

+    if(gMessageSystem->mVerboseLog)

+    {

+        LL_INFOS() << "MSG: -> " << host << "\tREAD PAST END:\t"

+//              << mCurrentRecvPacketID << " "

+                << getMessageName() << LL_ENDL;

+    }

+    gMessageSystem->callExceptionFunc(MX_RAN_OFF_END_OF_PACKET);

+}

+

+static LLTrace::BlockTimerStatHandle FTM_PROCESS_MESSAGES("Process Messages");

+

+// decode a given message

+bool LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender )

+{

+    LL_RECORD_BLOCK_TIME(FTM_PROCESS_MESSAGES);

+

+    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

+        {

+            LL_ERRS() << "Unknown block type" << LL_ENDL;

+            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)

+                    {

+                        logRanOffEndOfPacket(sender, decode_pos, data_size);

+

+                        // default to 0 length variable blocks

+                        tsize = 0;

+                    }

+                    else

+                    {

+                        switch(data_size)

+                        {

+                        case 1:

+                            htolememcpy(&tsizeb, &buffer[decode_pos], MVT_U8, 1);

+                            tsize = tsizeb;

+                            break;

+                        case 2:

+                            htolememcpy(&tsizeh, &buffer[decode_pos], MVT_U16, 2);

+                            tsize = tsizeh;

+                            break;

+                        case 4:

+                            htolememcpy(&tsize, &buffer[decode_pos], MVT_U32, 4);

+                            break;

+                        default:

+                            LL_ERRS() << "Attempting to read variable field with unknown size of " << data_size << LL_ENDL;

+                            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)

+                    {

+                        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())

+    {

+        LL_DEBUGS() << "Empty message '" << mCurrentRMessageTemplate->mName << "' (no blocks)" << LL_ENDL;

+        return false;

+    }

+

+    {

+        static LLTimer decode_timer;

+

+        if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback())

+        {

+            decode_timer.reset();

+        }

+

+        if( !mCurrentRMessageTemplate->callHandlerFunc(gMessageSystem) )

+        {

+            LL_WARNS() << "Message from " << sender << " with no handler function received: " << mCurrentRMessageTemplate->mName << LL_ENDL;

+        }

+

+        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())

+                {

+                    LL_DEBUGS() << "--------- Message " << mCurrentRMessageTemplate->mName << " decode took " << decode_time << " seconds. (" <<

+                        mCurrentRMessageTemplate->mMaxDecodeTimePerMsg << " max, " <<

+                        (mCurrentRMessageTemplate->mTotalDecodeTime / mCurrentRMessageTemplate->mTotalDecoded) << " avg)" << LL_ENDL;

+                }

+            }

+        }

+    }

+    return true;

+}

+

+bool LLTemplateMessageReader::validateMessage(const U8* buffer,

+                                              S32 buffer_size,

+                                              const LLHost& sender,

+                                              bool trusted)

+{

+    mReceiveSize = buffer_size;

+    bool valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate );

+    if(valid)

+    {

+        mCurrentRMessageTemplate->mReceiveCount++;

+        //LL_DEBUGS() << "MessageRecvd:"

+        //                       << mCurrentRMessageTemplate->mName

+        //                       << " from " << sender << LL_ENDL;

+    }

+

+    if (valid && isBanned(trusted))

+    {

+        LL_WARNS("Messaging") << "LLMessageSystem::checkMessages "

+            << "received banned message "

+            << getMessageName()

+            << " from "

+            << ((trusted) ? "trusted " : "untrusted ")

+            << sender << LL_ENDL;

+        valid = false;

+    }

+

+    if(valid && isUdpBanned())

+    {

+        LL_WARNS() << "Received UDP black listed message "

+                <<  getMessageName()

+                << " from " << sender << LL_ENDL;

+        valid = false;

+    }

+    return valid;

+}

+

+bool LLTemplateMessageReader::readMessage(const U8* buffer,

+                                          const LLHost& sender)

+{

+    return decodeData(buffer, sender);

+}

+

+//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);

+}