Second Life viewer sources 1.15.0.2

1 files changed, 750 insertions, 0 deletions

diff --git a/linden/indra/llmessage/lltemplatemessagereader.cpp b/linden/indra/llmessage/lltemplatemessagereader.cpp
new file mode 100644
index 0000000..892efb8
--- /dev/null
+++ b/linden/indra/llmessage/lltemplatemessagereader.cpp
@@ -0,0 +1,750 @@
+#include "lltemplatemessagereader.h"
+
+#include "llfasttimer.h"
+#include "llmessagebuilder.h"
+#include "llmessagetemplate.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::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::iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
+        
+        if (iter == mCurrentRMessageData->mMemberBlocks.end())
+        {
+//              sprintf(errmsg, "Block %s not in message %s", bnamep, mCurrentRMessageData->mName);
+//              llerrs << errmsg << llendl;
+//              return -1;
+                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)
+        {
+                llerrs << "No message waiting for decode 4!" << llendl;
+                return -1;
+        }
+
+        if (!mCurrentRMessageData)
+        {
+                llerrs << "Invalid mCurrentRMessageData in getData!" << llendl;
+                return -1;
+        }
+
+        char *bnamep = (char *)blockname; 
+
+        LLMsgData::msg_blk_data_map_t::iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
+        
+        if (iter == mCurrentRMessageData->mMemberBlocks.end())
+        {
+                llerrs << "Block " << bnamep << " not in message "
+                        << mCurrentRMessageData->mName << llendl;
+                return -1;
+        }
+
+        char *vnamep = (char *)varname; 
+
+        LLMsgBlkData* msg_data = iter->second;
+        LLMsgVarData& vardata = msg_data->mMemberVarData[vnamep];
+        
+        if (!vardata.getName())
+        {
+                llerrs << "Variable " << varname << " not in message "
+                        << mCurrentRMessageData->mName << " block " << bnamep << llendl;
+                return -1;
+        }
+
+        if (mCurrentRMessageTemplate->mMemberBlocks[bnamep]->mType != MBT_SINGLE)
+        {
+                llerrs << "Block " << bnamep << " isn't type MBT_SINGLE,"
+                        " use getSize with blocknum argument!" << llendl;
+                return -1;
+        }
+
+        return vardata.getSize();
+}
+
+S32 LLTemplateMessageReader::getSize(const char *blockname, S32 blocknum, const char *varname)
+{
+        // is there a message ready to go?
+        if (mReceiveSize == -1)
+        {
+                llerrs << "No message waiting for decode 5!" << llendl;
+                return -1;
+        }
+
+        if (!mCurrentRMessageData)
+        {
+                llerrs << "Invalid mCurrentRMessageData in getData!" << llendl;
+                return -1;
+        }
+
+        char *bnamep = (char *)blockname + blocknum; 
+        char *vnamep = (char *)varname; 
+
+        LLMsgData::msg_blk_data_map_t::iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
+        
+        if (iter == mCurrentRMessageData->mMemberBlocks.end())
+        {
+                llerrs << "Block " << bnamep << " not in message "
+                        << mCurrentRMessageData->mName << llendl;
+                return -1;
+        }
+
+        LLMsgBlkData* msg_data = iter->second;
+        LLMsgVarData& vardata = msg_data->mMemberVarData[vnamep];
+        
+        if (!vardata.getName())
+        {
+                llerrs << "Variable " << vnamep << " not in message "
+                        <<  mCurrentRMessageData->mName << " block " << bnamep << llendl;
+                return -1;
+        }
+
+        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, 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, 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, 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, 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, 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';
+}
+
+//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)
+        {
+                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)
+        {
+                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
+        {
+                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 )
+{
+        // we've run off the end of the packet!
+        llwarns << "Ran off end of packet " << mCurrentRMessageTemplate->mName
+//                      << " with id " << mCurrentRecvPacketID 
+                        << " from " << host
+                        << llendl;
+        if(gMessageSystem->mVerboseLog)
+        {
+                llinfos << "MSG: -> " << host << "\tREAD PAST END:\t"
+//                              << mCurrentRecvPacketID << " "
+                                << getMessageName() << llendl;
+        }
+        gMessageSystem->callExceptionFunc(MX_RAN_OFF_END_OF_PACKET);
+}
+
+// decode a given message
+BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender )
+{
+        llassert( mReceiveSize >= 0 );
+        llassert( mCurrentRMessageTemplate);
+        llassert( !mCurrentRMessageData );
+        delete mCurrentRMessageData; // just to make sure
+
+        S32 decode_pos = LL_PACKET_ID_SIZE + (S32)(mCurrentRMessageTemplate->mFrequency);
+
+        // create base working data set
+        mCurrentRMessageData = new LLMsgData(mCurrentRMessageTemplate->mName);
+        
+        // loop through the template building the data structure as we go
+        for (LLMessageTemplate::message_block_map_t::iterator iter = mCurrentRMessageTemplate->mMemberBlocks.begin();
+                 iter != mCurrentRMessageTemplate->mMemberBlocks.end(); iter++)
+        {
+                LLMessageBlock* mbci = iter->second;
+                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)
+                        {
+                                logRanOffEndOfPacket( sender );
+                                return FALSE;
+                        }
+                        repeat_number = buffer[decode_pos];
+                        decode_pos++;
+                }
+                else
+                {
+                        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::iterator iter = mbci->mMemberVariables.begin();
+                                 iter != mbci->mMemberVariables.end(); iter++)
+                        {
+                                LLMessageVariable& mvci = *(iter->second);
+                                // 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 );
+                                                return FALSE;
+                                        }
+                                        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(&tsizeb, &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;
+
+                                        if ((decode_pos + (S32)tsize) > mReceiveSize)
+                                        {
+                                                logRanOffEndOfPacket( sender );
+                                                return FALSE;
+                                        }
+                                        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 );
+                                                return FALSE;
+                                        }
+
+                                        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;
+        }
+
+        {
+                static LLTimer decode_timer;
+
+                if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback())
+                {
+                        decode_timer.reset();
+                }
+
+                //      if( mCurrentRMessageTemplate->mName == _PREHASH_AgentToNewRegion )
+                //      {
+                //              VTResume();  // VTune
+                //      }
+
+                {
+                        LLFastTimer t(LLFastTimer::FTM_PROCESS_MESSAGES);
+                        if( !mCurrentRMessageTemplate->callHandlerFunc(gMessageSystem) )
+                        {
+                                llwarns << "Message from " << sender << " with no handler function received: " << mCurrentRMessageTemplate->mName << llendl;
+                        }
+                }
+
+                //      if( mCurrentRMessageTemplate->mName == _PREHASH_AgentToNewRegion )
+                //      {
+                //              VTPause();      // VTune
+                //      }
+
+                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)
+{
+        mReceiveSize = buffer_size;
+        BOOL result = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate );
+        if(result)
+        {
+                mCurrentRMessageTemplate->mReceiveCount++;
+                lldebugst(LLERR_MESSAGE) << "MessageRecvd:" 
+                                                                 << mCurrentRMessageTemplate->mName 
+                                                                 << " from " << sender << llendl;
+        }
+        return result;
+}
+
+BOOL LLTemplateMessageReader::readMessage(const U8* buffer, 
+                                                                                  const LLHost& sender)
+{
+        return decodeData(buffer, sender);
+}
+
+//virtual 
+const char* LLTemplateMessageReader::getMessageName() const
+{
+        static char empty_string[] = "";
+        return mCurrentRMessageTemplate ? mCurrentRMessageTemplate->mName : empty_string;
+}
+
+//virtual 
+bool LLTemplateMessageReader::isTrusted() const
+{
+        return mCurrentRMessageTemplate->getTrust() == MT_TRUST;
+}
+
+//virtual 
+bool LLTemplateMessageReader::isBanned(bool trustedSource) const
+{
+        return mCurrentRMessageTemplate->isBanned(trustedSource);
+}
+
+//virtual 
+void LLTemplateMessageReader::copyToBuilder(LLMessageBuilder& builder) const
+{
+        if(NULL == mCurrentRMessageTemplate)
+    {
+        return;
+    }
+        builder.copyFromMessageData(*mCurrentRMessageData);
+}