开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
lltemplatemessagereader.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：22k
源码类别：

游戏引擎

开发平台：

C++ Builder

lltemplatemessagereader.cpp：源码内容
  1. /** 
  2.  * @file lltemplatemessagereader.cpp
  3.  * @brief LLTemplateMessageReader class implementation.
  4.  *
  5.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2007-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  34. #include "lltemplatemessagereader.h"
  36. #include "llfasttimer.h"
  37. #include "llmessagebuilder.h"
  38. #include "llmessagetemplate.h"
  39. #include "llquaternion.h"
  40. #include "message.h"
  41. #include "u64.h"
  42. #include "v3dmath.h"
  43. #include "v3math.h"
  44. #include "v4math.h"
  46. LLTemplateMessageReader::LLTemplateMessageReader(message_template_number_map_t&
  47.  number_template_map) :
  48. mReceiveSize(0),
  49. mCurrentRMessageTemplate(NULL),
  50. mCurrentRMessageData(NULL),
  51. mMessageNumbers(number_template_map)
  52. {
  53. }
  55. //virtual 
  56. LLTemplateMessageReader::~LLTemplateMessageReader()
  57. {
  58. delete mCurrentRMessageData;
  59. mCurrentRMessageData = NULL;
  60. }
  62. //virtual
  63. void LLTemplateMessageReader::clearMessage()
  64. {
  65. mReceiveSize = -1;
  66. mCurrentRMessageTemplate = NULL;
  67. delete mCurrentRMessageData;
  68. mCurrentRMessageData = NULL;
  69. }
  71. void LLTemplateMessageReader::getData(const char *blockname, const char *varname, void *datap, S32 size, S32 blocknum, S32 max_size)
  72. {
  73. // is there a message ready to go?
  74. if (mReceiveSize == -1)
  75. {
  76. llerrs << "No message waiting for decode 2!" << llendl;
  77. return;
  78. }
  80. if (!mCurrentRMessageData)
  81. {
  82. llerrs << "Invalid mCurrentMessageData in getData!" << llendl;
  83. return;
  84. }
  86. char *bnamep = (char *)blockname + blocknum; // this works because it's just a hash.  The bnamep is never derefference
  87. char *vnamep = (char *)varname; 
  89. LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
  91. if (iter == mCurrentRMessageData->mMemberBlocks.end())
  92. {
  93. llerrs << "Block " << blockname << " #" << blocknum
  94. << " not in message " << mCurrentRMessageData->mName << llendl;
  95. return;
  96. }
  98. LLMsgBlkData *msg_block_data = iter->second;
  99. LLMsgVarData& vardata = msg_block_data->mMemberVarData[vnamep];
  101. if (!vardata.getName())
  102. {
  103. llerrs << "Variable "<< vnamep << " not in message "
  104. << mCurrentRMessageData->mName<< " block " << bnamep << llendl;
  105. return;
  106. }
  108. if (size && size != vardata.getSize())
  109. {
  110. llerrs << "Msg " << mCurrentRMessageData->mName 
  111. << " variable " << vnamep
  112. << " is size " << vardata.getSize()
  113. << " but copying into buffer of size " << size
  114. << llendl;
  115. return;
  116. }
  119. const S32 vardata_size = vardata.getSize();
  120. if( max_size >= vardata_size )
  121. {   
  122. switch( vardata_size )
  123. { 
  124. case 1:
  125. *((U8*)datap) = *((U8*)vardata.getData());
  126. break;
  127. case 2:
  128. *((U16*)datap) = *((U16*)vardata.getData());
  129. break;
  130. case 4:
  131. *((U32*)datap) = *((U32*)vardata.getData());
  132. break;
  133. case 8:
  134. ((U32*)datap)[0] = ((U32*)vardata.getData())[0];
  135. ((U32*)datap)[1] = ((U32*)vardata.getData())[1];
  136. break;
  137. default:
  138. memcpy(datap, vardata.getData(), vardata_size);
  139. break;
  140. }
  141. }
  142. else
  143. {
  144. llwarns << "Msg " << mCurrentRMessageData->mName 
  145. << " variable " << vnamep
  146. << " is size " << vardata.getSize()
  147. << " but truncated to max size of " << max_size
  148. << llendl;
  150. memcpy(datap, vardata.getData(), max_size);
  151. }
  152. }
  154. S32 LLTemplateMessageReader::getNumberOfBlocks(const char *blockname)
  155. {
  156. // is there a message ready to go?
  157. if (mReceiveSize == -1)
  158. {
  159. llerrs << "No message waiting for decode 3!" << llendl;
  160. return -1;
  161. }
  163. if (!mCurrentRMessageData)
  164. {
  165. llerrs << "Invalid mCurrentRMessageData in getData!" << llendl;
  166. return -1;
  167. }
  169. char *bnamep = (char *)blockname; 
  171. LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
  173. if (iter == mCurrentRMessageData->mMemberBlocks.end())
  174. {
  175. return 0;
  176. }
  178. return (iter->second)->mBlockNumber;
  179. }
  181. S32 LLTemplateMessageReader::getSize(const char *blockname, const char *varname)
  182. {
  183. // is there a message ready to go?
  184. if (mReceiveSize == -1)
  185. { // This is a serious error - crash 
  186. llerrs << "No message waiting for decode 4!" << llendl;
  187. return LL_MESSAGE_ERROR;
  188. }
  190. if (!mCurrentRMessageData)
  191. { // This is a serious error - crash
  192. llerrs << "Invalid mCurrentRMessageData in getData!" << llendl;
  193. return LL_MESSAGE_ERROR;
  194. }
  196. char *bnamep = (char *)blockname; 
  198. LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
  200. if (iter == mCurrentRMessageData->mMemberBlocks.end())
  201. { // don't crash
  202. llinfos << "Block " << bnamep << " not in message "
  203. << mCurrentRMessageData->mName << llendl;
  204. return LL_BLOCK_NOT_IN_MESSAGE;
  205. }
  207. char *vnamep = (char *)varname; 
  209. LLMsgBlkData* msg_data = iter->second;
  210. LLMsgVarData& vardata = msg_data->mMemberVarData[vnamep];
  212. if (!vardata.getName())
  213. { // don't crash
  214. llinfos << "Variable " << varname << " not in message "
  215. << mCurrentRMessageData->mName << " block " << bnamep << llendl;
  216. return LL_VARIABLE_NOT_IN_BLOCK;
  217. }
  219. if (mCurrentRMessageTemplate->mMemberBlocks[bnamep]->mType != MBT_SINGLE)
  220. { // This is a serious error - crash
  221. llerrs << "Block " << bnamep << " isn't type MBT_SINGLE,"
  222. " use getSize with blocknum argument!" << llendl;
  223. return LL_MESSAGE_ERROR;
  224. }
  226. return vardata.getSize();
  227. }
  229. S32 LLTemplateMessageReader::getSize(const char *blockname, S32 blocknum, const char *varname)
  230. {
  231. // is there a message ready to go?
  232. if (mReceiveSize == -1)
  233. { // This is a serious error - crash
  234. llerrs << "No message waiting for decode 5!" << llendl;
  235. return LL_MESSAGE_ERROR;
  236. }
  238. if (!mCurrentRMessageData)
  239. { // This is a serious error - crash
  240. llerrs << "Invalid mCurrentRMessageData in getData!" << llendl;
  241. return LL_MESSAGE_ERROR;
  242. }
  244. char *bnamep = (char *)blockname + blocknum; 
  245. char *vnamep = (char *)varname; 
  247. LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep);
  249. if (iter == mCurrentRMessageData->mMemberBlocks.end())
  250. { // don't crash
  251. llinfos << "Block " << bnamep << " not in message " 
  252. << mCurrentRMessageData->mName << llendl;
  253. return LL_BLOCK_NOT_IN_MESSAGE;
  254. }
  256. LLMsgBlkData* msg_data = iter->second;
  257. LLMsgVarData& vardata = msg_data->mMemberVarData[vnamep];
  259. if (!vardata.getName())
  260. { // don't crash
  261. llinfos << "Variable " << vnamep << " not in message "
  262. <<  mCurrentRMessageData->mName << " block " << bnamep << llendl;
  263. return LL_VARIABLE_NOT_IN_BLOCK;
  264. }
  266. return vardata.getSize();
  267. }
  269. void LLTemplateMessageReader::getBinaryData(const char *blockname, 
  270. const char *varname, void *datap, 
  271. S32 size, S32 blocknum, 
  272. S32 max_size)
  273. {
  274. getData(blockname, varname, datap, size, blocknum, max_size);
  275. }
  277. void LLTemplateMessageReader::getS8(const char *block, const char *var, 
  278. S8 &u, S32 blocknum)
  279. {
  280. getData(block, var, &u, sizeof(S8), blocknum);
  281. }
  283. void LLTemplateMessageReader::getU8(const char *block, const char *var, 
  284. U8 &u, S32 blocknum)
  285. {
  286. getData(block, var, &u, sizeof(U8), blocknum);
  287. }
  289. void LLTemplateMessageReader::getBOOL(const char *block, const char *var, 
  290.   BOOL &b, S32 blocknum )
  291. {
  292. U8 value;
  293. getData(block, var, &value, sizeof(U8), blocknum);
  294. b = (BOOL) value;
  295. }
  297. void LLTemplateMessageReader::getS16(const char *block, const char *var, 
  298.  S16 &d, S32 blocknum)
  299. {
  300. getData(block, var, &d, sizeof(S16), blocknum);
  301. }
  303. void LLTemplateMessageReader::getU16(const char *block, const char *var, 
  304.  U16 &d, S32 blocknum)
  305. {
  306. getData(block, var, &d, sizeof(U16), blocknum);
  307. }
  309. void LLTemplateMessageReader::getS32(const char *block, const char *var, 
  310.  S32 &d, S32 blocknum)
  311. {
  312. getData(block, var, &d, sizeof(S32), blocknum);
  313. }
  315. void LLTemplateMessageReader::getU32(const char *block, const char *var, 
  316.  U32 &d, S32 blocknum)
  317. {
  318. getData(block, var, &d, sizeof(U32), blocknum);
  319. }
  321. void LLTemplateMessageReader::getU64(const char *block, const char *var, 
  322.  U64 &d, S32 blocknum)
  323. {
  324. getData(block, var, &d, sizeof(U64), blocknum);
  325. }
  327. void LLTemplateMessageReader::getF32(const char *block, const char *var, 
  328.  F32 &d, S32 blocknum)
  329. {
  330. getData(block, var, &d, sizeof(F32), blocknum);
  332. if( !llfinite( d ) )
  333. {
  334. llwarns << "non-finite in getF32Fast " << block << " " << var 
  335. << llendl;
  336. d = 0;
  337. }
  338. }
  340. void LLTemplateMessageReader::getF64(const char *block, const char *var, 
  341.  F64 &d, S32 blocknum)
  342. {
  343. getData(block, var, &d, sizeof(F64), blocknum);
  345. if( !llfinite( d ) )
  346. {
  347. llwarns << "non-finite in getF64Fast " << block << " " << var 
  348. << llendl;
  349. d = 0;
  350. }
  351. }
  353. void LLTemplateMessageReader::getVector3(const char *block, const char *var, 
  354.  LLVector3 &v, S32 blocknum )
  355. {
  356. getData(block, var, &v.mV[0], sizeof(v.mV), blocknum);
  358. if( !v.isFinite() )
  359. {
  360. llwarns << "non-finite in getVector3Fast " << block << " " 
  361. << var << llendl;
  362. v.zeroVec();
  363. }
  364. }
  366. void LLTemplateMessageReader::getVector4(const char *block, const char *var, 
  367.  LLVector4 &v, S32 blocknum)
  368. {
  369. getData(block, var, &v.mV[0], sizeof(v.mV), blocknum);
  371. if( !v.isFinite() )
  372. {
  373. llwarns << "non-finite in getVector4Fast " << block << " " 
  374. << var << llendl;
  375. v.zeroVec();
  376. }
  377. }
  379. void LLTemplateMessageReader::getVector3d(const char *block, const char *var, 
  380.   LLVector3d &v, S32 blocknum )
  381. {
  382. getData(block, var, &v.mdV[0], sizeof(v.mdV), blocknum);
  384. if( !v.isFinite() )
  385. {
  386. llwarns << "non-finite in getVector3dFast " << block << " " 
  387. << var << llendl;
  388. v.zeroVec();
  389. }
  391. }
  393. void LLTemplateMessageReader::getQuat(const char *block, const char *var, 
  394.   LLQuaternion &q, S32 blocknum)
  395. {
  396. LLVector3 vec;
  397. getData(block, var, &vec.mV[0], sizeof(vec.mV), blocknum);
  398. if( vec.isFinite() )
  399. {
  400. q.unpackFromVector3( vec );
  401. }
  402. else
  403. {
  404. llwarns << "non-finite in getQuatFast " << block << " " << var 
  405. << llendl;
  406. q.loadIdentity();
  407. }
  408. }
  410. void LLTemplateMessageReader::getUUID(const char *block, const char *var, 
  411.   LLUUID &u, S32 blocknum)
  412. {
  413. getData(block, var, &u.mData[0], sizeof(u.mData), blocknum);
  414. }
  416. inline void LLTemplateMessageReader::getIPAddr(const char *block, const char *var, U32 &u, S32 blocknum)
  417. {
  418. getData(block, var, &u, sizeof(U32), blocknum);
  419. }
  421. inline void LLTemplateMessageReader::getIPPort(const char *block, const char *var, U16 &u, S32 blocknum)
  422. {
  423. getData(block, var, &u, sizeof(U16), blocknum);
  424. u = ntohs(u);
  425. }
  427. inline void LLTemplateMessageReader::getString(const char *block, const char *var, S32 buffer_size, char *s, S32 blocknum )
  428. {
  429. s[0] = '';
  430. getData(block, var, s, 0, blocknum, buffer_size);
  431. s[buffer_size - 1] = '';
  432. }
  434. inline void LLTemplateMessageReader::getString(const char *block, const char *var, std::string& outstr, S32 blocknum )
  435. {
  436. char s[MTUBYTES];
  437. s[0] = '';
  438. getData(block, var, s, 0, blocknum, MTUBYTES);
  439. s[MTUBYTES - 1] = '';
  440. outstr = s;
  441. }
  443. //virtual 
  444. S32 LLTemplateMessageReader::getMessageSize() const
  445. {
  446. return mReceiveSize;
  447. }
  449. // Returns template for the message contained in buffer
  450. BOOL LLTemplateMessageReader::decodeTemplate(  
  451. const U8* buffer, S32 buffer_size,  // inputs
  452. LLMessageTemplate** msg_template ) // outputs
  453. {
  454. const U8* header = buffer + LL_PACKET_ID_SIZE;
  456. // is there a message ready to go?
  457. if (buffer_size <= 0)
  458. {
  459. llwarns << "No message waiting for decode!" << llendl;
  460. return(FALSE);
  461. }
  463. U32 num = 0;
  465. if (header[0] != 255)
  466. {
  467. // high frequency message
  468. num = header[0];
  469. }
  470. else if ((buffer_size >= ((S32) LL_MINIMUM_VALID_PACKET_SIZE + 1)) && (header[1] != 255))
  471. {
  472. // medium frequency message
  473. num = (255 << 8) | header[1];
  474. }
  475. else if ((buffer_size >= ((S32) LL_MINIMUM_VALID_PACKET_SIZE + 3)) && (header[1] == 255))
  476. {
  477. // low frequency message
  478. U16 message_id_U16 = 0;
  479. // I think this check busts the message system.
  480. // it appears that if there is a NULL in the message #, it won't copy it....
  481. // what was the goal?
  482. //if(header[2])
  483. memcpy(&message_id_U16, &header[2], 2);
  485. // dependant on endian-ness:
  486. // U32 temp = (255 << 24) | (255 << 16) | header[2];
  488. // independant of endian-ness:
  489. message_id_U16 = ntohs(message_id_U16);
  490. num = 0xFFFF0000 | message_id_U16;
  491. }
  492. else // bogus packet received (too short)
  493. {
  494. llwarns << "Packet with unusable length received (too short): "
  495. << buffer_size << llendl;
  496. return(FALSE);
  497. }
  499. LLMessageTemplate* temp = get_ptr_in_map(mMessageNumbers,num);
  500. if (temp)
  501. {
  502. *msg_template = temp;
  503. }
  504. else
  505. {
  506. llwarns << "Message #" << std::hex << num << std::dec
  507. << " received but not registered!" << llendl;
  508. gMessageSystem->callExceptionFunc(MX_UNREGISTERED_MESSAGE);
  509. return(FALSE);
  510. }
  512. return(TRUE);
  513. }
  515. void LLTemplateMessageReader::logRanOffEndOfPacket( const LLHost& host, const S32 where, const S32 wanted )
  516. {
  517. // we've run off the end of the packet!
  518. llwarns << "Ran off end of packet " << mCurrentRMessageTemplate->mName
  519. // << " with id " << mCurrentRecvPacketID 
  520. << " from " << host
  521. << " trying to read " << wanted
  522. << " bytes at position " << where
  523. << " going past packet end at " << mReceiveSize
  524. << llendl;
  525. if(gMessageSystem->mVerboseLog)
  526. {
  527. llinfos << "MSG: -> " << host << "tREAD PAST END:t"
  528. // << mCurrentRecvPacketID << " "
  529. << getMessageName() << llendl;
  530. }
  531. gMessageSystem->callExceptionFunc(MX_RAN_OFF_END_OF_PACKET);
  532. }
  534. static LLFastTimer::DeclareTimer FTM_PROCESS_MESSAGES("Process Messages");
  536. // decode a given message
  537. BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender )
  538. {
  539. llassert( mReceiveSize >= 0 );
  540. llassert( mCurrentRMessageTemplate);
  541. llassert( !mCurrentRMessageData );
  542. delete mCurrentRMessageData; // just to make sure
  544. // The offset tells us how may bytes to skip after the end of the
  545. // message name.
  546. U8 offset = buffer[PHL_OFFSET];
  547. S32 decode_pos = LL_PACKET_ID_SIZE + (S32)(mCurrentRMessageTemplate->mFrequency) + offset;
  549. // create base working data set
  550. mCurrentRMessageData = new LLMsgData(mCurrentRMessageTemplate->mName);
  552. // loop through the template building the data structure as we go
  553. LLMessageTemplate::message_block_map_t::const_iterator iter;
  554. for(iter = mCurrentRMessageTemplate->mMemberBlocks.begin();
  555. iter != mCurrentRMessageTemplate->mMemberBlocks.end();
  556. ++iter)
  557. {
  558. LLMessageBlock* mbci = *iter;
  559. U8 repeat_number;
  560. S32 i;
  562. // how many of this block?
  564. if (mbci->mType == MBT_SINGLE)
  565. {
  566. // just one
  567. repeat_number = 1;
  568. }
  569. else if (mbci->mType == MBT_MULTIPLE)
  570. {
  571. // a known number
  572. repeat_number = mbci->mNumber;
  573. }
  574. else if (mbci->mType == MBT_VARIABLE)
  575. {
  576. // need to read the number from the message
  577. // repeat number is a single byte
  578. if (decode_pos >= mReceiveSize)
  579. {
  580. // commented out - hetgrid says that missing variable blocks
  581. // at end of message are legal
  582. // logRanOffEndOfPacket(sender, decode_pos, 1);
  584. // default to 0 repeats
  585. repeat_number = 0;
  586. }
  587. else
  588. {
  589. repeat_number = buffer[decode_pos];
  590. decode_pos++;
  591. }
  592. }
  593. else
  594. {
  595. llerrs << "Unknown block type" << llendl;
  596. return FALSE;
  597. }
  599. LLMsgBlkData* cur_data_block = NULL;
  601. // now loop through the block
  602. for (i = 0; i < repeat_number; i++)
  603. {
  604. if (i)
  605. {
  606. // build new name to prevent collisions
  607. // TODO: This should really change to a vector
  608. cur_data_block = new LLMsgBlkData(mbci->mName, repeat_number);
  609. cur_data_block->mName = mbci->mName + i;
  610. }
  611. else
  612. {
  613. cur_data_block = new LLMsgBlkData(mbci->mName, repeat_number);
  614. }
  616. // add the block to the message
  617. mCurrentRMessageData->addBlock(cur_data_block);
  619. // now read the variables
  620. for (LLMessageBlock::message_variable_map_t::const_iterator iter = 
  621.  mbci->mMemberVariables.begin();
  622.  iter != mbci->mMemberVariables.end(); iter++)
  623. {
  624. const LLMessageVariable& mvci = **iter;
  626. // ok, build out the variables
  627. // add variable block
  628. cur_data_block->addVariable(mvci.getName(), mvci.getType());
  630. // what type of variable?
  631. if (mvci.getType() == MVT_VARIABLE)
  632. {
  633. // variable, get the number of bytes to read from the template
  634. S32 data_size = mvci.getSize();
  635. U8 tsizeb = 0;
  636. U16 tsizeh = 0;
  637. U32 tsize = 0;
  639. if ((decode_pos + data_size) > mReceiveSize)
  640. {
  641. logRanOffEndOfPacket(sender, decode_pos, data_size);
  643. // default to 0 length variable blocks
  644. tsize = 0;
  645. }
  646. else
  647. {
  648. switch(data_size)
  649. {
  650. case 1:
  651. htonmemcpy(&tsizeb, &buffer[decode_pos], MVT_U8, 1);
  652. tsize = tsizeb;
  653. break;
  654. case 2:
  655. htonmemcpy(&tsizeh, &buffer[decode_pos], MVT_U16, 2);
  656. tsize = tsizeh;
  657. break;
  658. case 4:
  659. htonmemcpy(&tsize, &buffer[decode_pos], MVT_U32, 4);
  660. break;
  661. default:
  662. llerrs << "Attempting to read variable field with unknown size of " << data_size << llendl;
  663. break;
  664. }
  665. }
  666. decode_pos += data_size;
  668. cur_data_block->addData(mvci.getName(), &buffer[decode_pos], tsize, mvci.getType());
  669. decode_pos += tsize;
  670. }
  671. else
  672. {
  673. // fixed!
  674. // so, copy data pointer and set data size to fixed size
  675. if ((decode_pos + mvci.getSize()) > mReceiveSize)
  676. {
  677. logRanOffEndOfPacket(sender, decode_pos, mvci.getSize());
  679. // default to 0s.
  680. U32 size = mvci.getSize();
  681. std::vector<U8> data(size, 0);
  682. cur_data_block->addData(mvci.getName(), &(data[0]), 
  683. size, mvci.getType());
  684. }
  685. else
  686. {
  687. cur_data_block->addData(mvci.getName(), 
  688. &buffer[decode_pos], 
  689. mvci.getSize(), 
  690. mvci.getType());
  691. }
  692. decode_pos += mvci.getSize();
  693. }
  694. }
  695. }
  696. }
  698. if (mCurrentRMessageData->mMemberBlocks.empty()
  699. && !mCurrentRMessageTemplate->mMemberBlocks.empty())
  700. {
  701. lldebugs << "Empty message '" << mCurrentRMessageTemplate->mName << "' (no blocks)" << llendl;
  702. return FALSE;
  703. }
  705. {
  706. static LLTimer decode_timer;
  708. if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback())
  709. {
  710. decode_timer.reset();
  711. }
  713. {
  714. LLFastTimer t(FTM_PROCESS_MESSAGES);
  715. if( !mCurrentRMessageTemplate->callHandlerFunc(gMessageSystem) )
  716. {
  717. llwarns << "Message from " << sender << " with no handler function received: " << mCurrentRMessageTemplate->mName << llendl;
  718. }
  719. }
  721. if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback())
  722. {
  723. F32 decode_time = decode_timer.getElapsedTimeF32();
  725. if (gMessageSystem->getTimingCallback())
  726. {
  727. (gMessageSystem->getTimingCallback())(mCurrentRMessageTemplate->mName,
  728. decode_time,
  729. gMessageSystem->getTimingCallbackData());
  730. }
  732. if (LLMessageReader::getTimeDecodes())
  733. {
  734. mCurrentRMessageTemplate->mDecodeTimeThisFrame += decode_time;
  736. mCurrentRMessageTemplate->mTotalDecoded++;
  737. mCurrentRMessageTemplate->mTotalDecodeTime += decode_time;
  739. if( mCurrentRMessageTemplate->mMaxDecodeTimePerMsg < decode_time )
  740. {
  741. mCurrentRMessageTemplate->mMaxDecodeTimePerMsg = decode_time;
  742. }
  745. if(decode_time > LLMessageReader::getTimeDecodesSpamThreshold())
  746. {
  747. lldebugs << "--------- Message " << mCurrentRMessageTemplate->mName << " decode took " << decode_time << " seconds. (" <<
  748. mCurrentRMessageTemplate->mMaxDecodeTimePerMsg << " max, " <<
  749. (mCurrentRMessageTemplate->mTotalDecodeTime / mCurrentRMessageTemplate->mTotalDecoded) << " avg)" << llendl;
  750. }
  751. }
  752. }
  753. }
  754. return TRUE;
  755. }
  757. BOOL LLTemplateMessageReader::validateMessage(const U8* buffer, 
  758.   S32 buffer_size, 
  759.   const LLHost& sender,
  760.   bool trusted)
  761. {
  762. mReceiveSize = buffer_size;
  763. BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate );
  764. if(valid)
  765. {
  766. mCurrentRMessageTemplate->mReceiveCount++;
  767. //lldebugs << "MessageRecvd:"
  768. //  << mCurrentRMessageTemplate->mName 
  769. //  << " from " << sender << llendl;
  770. }
  772. if (valid && isBanned(trusted))
  773. {
  774. LL_WARNS("Messaging") << "LLMessageSystem::checkMessages "
  775. << "received banned message "
  776. << getMessageName()
  777. << " from "
  778. << ((trusted) ? "trusted " : "untrusted ")
  779. << sender << llendl;
  780. valid = FALSE;
  781. }
  783. if(valid && isUdpBanned())
  784. {
  785. llwarns << "Received UDP black listed message "
  786. <<  getMessageName()
  787. << " from " << sender << llendl;
  788. valid = FALSE;
  789. }
  790. return valid;
  791. }
  793. BOOL LLTemplateMessageReader::readMessage(const U8* buffer, 
  794.   const LLHost& sender)
  795. {
  796. return decodeData(buffer, sender);
  797. }
  799. //virtual 
  800. const char* LLTemplateMessageReader::getMessageName() const
  801. {
  802. if (!mCurrentRMessageTemplate)
  803. {
  804. llwarns << "no mCurrentRMessageTemplate" << llendl;
  805. return "";
  806. }
  807. return mCurrentRMessageTemplate->mName;
  808. }
  810. //virtual 
  811. bool LLTemplateMessageReader::isTrusted() const
  812. {
  813. return mCurrentRMessageTemplate->getTrust() == MT_TRUST;
  814. }
  816. bool LLTemplateMessageReader::isBanned(bool trustedSource) const
  817. {
  818. return mCurrentRMessageTemplate->isBanned(trustedSource);
  819. }
  821. bool LLTemplateMessageReader::isUdpBanned() const
  822. {
  823. return mCurrentRMessageTemplate->isUdpBanned();
  824. }
  826. //virtual 
  827. void LLTemplateMessageReader::copyToBuilder(LLMessageBuilder& builder) const
  828. {
  829. if(NULL == mCurrentRMessageTemplate)
  830.     {
  831.         return;
  832.     }
  833. builder.copyFromMessageData(*mCurrentRMessageData);
  834. }