message.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:110k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file message.cpp
  3.  * @brief LLMessageSystem class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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.  */
  32. #include "linden_common.h"
  33. #include "message.h"
  34. // system library includes
  35. #if !LL_WINDOWS
  36. // following header files required for inet_addr()
  37. #include <sys/types.h>
  38. #include <sys/socket.h>
  39. #include <netinet/in.h>
  40. #include <arpa/inet.h>
  41. #endif
  42. #include <iomanip>
  43. #include <iterator>
  44. #include <sstream>
  45. #include "llapr.h"
  46. #include "apr_portable.h"
  47. #include "apr_network_io.h"
  48. #include "apr_poll.h"
  49. // linden library headers
  50. #include "indra_constants.h"
  51. #include "lldarray.h"
  52. #include "lldir.h"
  53. #include "llerror.h"
  54. #include "llerrorlegacy.h"
  55. #include "llfasttimer.h"
  56. #include "llhttpclient.h"
  57. #include "llhttpnodeadapter.h"
  58. #include "llhttpsender.h"
  59. #include "llmd5.h"
  60. #include "llmessagebuilder.h"
  61. #include "llmessageconfig.h"
  62. #include "lltemplatemessagedispatcher.h"
  63. #include "llpumpio.h"
  64. #include "lltemplatemessagebuilder.h"
  65. #include "lltemplatemessagereader.h"
  66. #include "lltrustedmessageservice.h"
  67. #include "llmessagetemplate.h"
  68. #include "llmessagetemplateparser.h"
  69. #include "llsd.h"
  70. #include "llsdmessagebuilder.h"
  71. #include "llsdmessagereader.h"
  72. #include "llsdserialize.h"
  73. #include "llstring.h"
  74. #include "lltransfermanager.h"
  75. #include "lluuid.h"
  76. #include "llxfermanager.h"
  77. #include "timing.h"
  78. #include "llquaternion.h"
  79. #include "u64.h"
  80. #include "v3dmath.h"
  81. #include "v3math.h"
  82. #include "v4math.h"
  83. #include "lltransfertargetvfile.h"
  84. #include "llmemtype.h"
  85. // Constants
  86. //const char* MESSAGE_LOG_FILENAME = "message.log";
  87. static const F32 CIRCUIT_DUMP_TIMEOUT = 30.f;
  88. static const S32 TRUST_TIME_WINDOW = 3;
  89. // *NOTE: This needs to be moved into a seperate file so that it never gets
  90. // included in the viewer.  30 Sep 2002 mark
  91. // *NOTE: I don't think it's important that the messgage system tracks
  92. // this since it must get set externally. 2004.08.25 Phoenix.
  93. static std::string g_shared_secret;
  94. std::string get_shared_secret();
  95. class LLMessagePollInfo
  96. {
  97. public:
  98. apr_socket_t *mAPRSocketp;
  99. apr_pollfd_t mPollFD;
  100. };
  101. namespace
  102. {
  103. class LLFnPtrResponder : public LLHTTPClient::Responder
  104. {
  105. LOG_CLASS(LLFnPtrResponder);
  106. public:
  107. LLFnPtrResponder(void (*callback)(void **,S32), void **callbackData, const std::string& name) :
  108. mCallback(callback),
  109. mCallbackData(callbackData),
  110. mMessageName(name)
  111. {
  112. }
  113. virtual void error(U32 status, const std::string& reason)
  114. {
  115. // don't spam when agent communication disconnected already
  116. if (status != 410)
  117. {
  118. LL_WARNS("Messaging") << "error status " << status
  119. << " for message " << mMessageName
  120. << " reason " << reason << llendl;
  121. }
  122. // TODO: Map status in to useful error code.
  123. if(NULL != mCallback) mCallback(mCallbackData, LL_ERR_TCP_TIMEOUT);
  124. }
  125. virtual void result(const LLSD& content)
  126. {
  127. if(NULL != mCallback) mCallback(mCallbackData, LL_ERR_NOERR);
  128. }
  129. private:
  130. void (*mCallback)(void **,S32);    
  131. void **mCallbackData;
  132. std::string mMessageName;
  133. };
  134. }
  135. class LLMessageHandlerBridge : public LLHTTPNode
  136. {
  137. virtual bool validate(const std::string& name, LLSD& context) const
  138. { return true; }
  139. virtual void post(LLHTTPNode::ResponsePtr response, const LLSD& context, 
  140.   const LLSD& input) const;
  141. };
  142. //virtual 
  143. void LLMessageHandlerBridge::post(LLHTTPNode::ResponsePtr response, 
  144. const LLSD& context, const LLSD& input) const
  145. {
  146. std::string name = context["request"]["wildcard"]["message-name"];
  147. char* namePtr = LLMessageStringTable::getInstance()->getString(name.c_str());
  148. lldebugs << "Setting mLastSender " << input["sender"].asString() << llendl;
  149. gMessageSystem->mLastSender = LLHost(input["sender"].asString());
  150. gMessageSystem->mPacketsIn += 1;
  151. gMessageSystem->mLLSDMessageReader->setMessage(namePtr, input["body"]);
  152. gMessageSystem->mMessageReader = gMessageSystem->mLLSDMessageReader;
  153. if(gMessageSystem->callHandler(namePtr, false, gMessageSystem))
  154. {
  155. response->result(LLSD());
  156. }
  157. else
  158. {
  159. response->notFound();
  160. }
  161. }
  162. LLHTTPRegistration<LLMessageHandlerBridge>
  163. gHTTPRegistrationMessageWildcard("/message/<message-name>");
  164. //virtual
  165. LLUseCircuitCodeResponder::~LLUseCircuitCodeResponder()
  166. {
  167. // even abstract base classes need a concrete destructor
  168. }
  169. static const char* nullToEmpty(const char* s)
  170. {
  171. static char emptyString[] = "";
  172. return s? s : emptyString;
  173. }
  174. void LLMessageSystem::init()
  175. {
  176. // initialize member variables
  177. mVerboseLog = FALSE;
  178. mbError = FALSE;
  179. mErrorCode = 0;
  180. mSendReliable = FALSE;
  181. mUnackedListDepth = 0;
  182. mUnackedListSize = 0;
  183. mDSMaxListDepth = 0;
  184. mNumberHighFreqMessages = 0;
  185. mNumberMediumFreqMessages = 0;
  186. mNumberLowFreqMessages = 0;
  187. mPacketsIn = mPacketsOut = 0;
  188. mBytesIn = mBytesOut = 0;
  189. mCompressedPacketsIn = mCompressedPacketsOut = 0;
  190. mReliablePacketsIn = mReliablePacketsOut = 0;
  191. mCompressedBytesIn = 0;
  192. mCompressedBytesOut = 0;
  193. mUncompressedBytesIn = 0;
  194. mUncompressedBytesOut = 0;
  195. mTotalBytesIn = 0;
  196. mTotalBytesOut = 0;
  197.     mDroppedPackets = 0;            // total dropped packets in
  198.     mResentPackets = 0;             // total resent packets out
  199.     mFailedResendPackets = 0;       // total resend failure packets out
  200.     mOffCircuitPackets = 0;         // total # of off-circuit packets rejected
  201.     mInvalidOnCircuitPackets = 0;   // total # of on-circuit packets rejected
  202. mOurCircuitCode = 0;
  203. mIncomingCompressedSize = 0;
  204. mCurrentRecvPacketID = 0;
  205. mMessageFileVersionNumber = 0.f;
  206. mTimingCallback = NULL;
  207. mTimingCallbackData = NULL;
  208. mMessageBuilder = NULL;
  209. mMessageReader = NULL;
  210. }
  211. // Read file and build message templates
  212. LLMessageSystem::LLMessageSystem(const std::string& filename, U32 port, 
  213.  S32 version_major,
  214.  S32 version_minor,
  215.  S32 version_patch,
  216.  bool failure_is_fatal,
  217.  const F32 circuit_heartbeat_interval, const F32 circuit_timeout) :
  218. mCircuitInfo(circuit_heartbeat_interval, circuit_timeout),
  219. mLastMessageFromTrustedMessageService(false)
  220. {
  221. init();
  222. mSendSize = 0;
  223. mSystemVersionMajor = version_major;
  224. mSystemVersionMinor = version_minor;
  225. mSystemVersionPatch = version_patch;
  226. mSystemVersionServer = 0;
  227. mVersionFlags = 0x0;
  228. // default to not accepting packets from not alive circuits
  229. mbProtected = TRUE;
  230. // default to blocking trusted connections on a public interface if one is specified
  231. mBlockUntrustedInterface = true;
  232. mSendPacketFailureCount = 0;
  233. mCircuitPrintFreq = 60.f; // seconds
  234. loadTemplateFile(filename, failure_is_fatal);
  235. mTemplateMessageBuilder = new LLTemplateMessageBuilder(mMessageTemplates);
  236. mLLSDMessageBuilder = new LLSDMessageBuilder();
  237. mMessageBuilder = NULL;
  238. mTemplateMessageReader = new LLTemplateMessageReader(mMessageNumbers);
  239. mLLSDMessageReader = new LLSDMessageReader();
  240. mMessageReader = NULL;
  241. // initialize various bits of net info
  242. mSocket = 0;
  243. mPort = port;
  244. S32 error = start_net(mSocket, mPort);
  245. if (error != 0)
  246. {
  247. mbError = TRUE;
  248. mErrorCode = error;
  249. }
  250. // LL_DEBUGS("Messaging") <<  << "*** port: " << mPort << llendl;
  251. //
  252. // Create the data structure that we can poll on
  253. //
  254. if (!gAPRPoolp)
  255. {
  256. LL_ERRS("Messaging") << "No APR pool before message system initialization!" << llendl;
  257. ll_init_apr();
  258. }
  259. apr_socket_t *aprSocketp = NULL;
  260. apr_os_sock_put(&aprSocketp, (apr_os_sock_t*)&mSocket, gAPRPoolp);
  261. mPollInfop = new LLMessagePollInfo;
  262. mPollInfop->mAPRSocketp = aprSocketp;
  263. mPollInfop->mPollFD.p = gAPRPoolp;
  264. mPollInfop->mPollFD.desc_type = APR_POLL_SOCKET;
  265. mPollInfop->mPollFD.reqevents = APR_POLLIN;
  266. mPollInfop->mPollFD.rtnevents = 0;
  267. mPollInfop->mPollFD.desc.s = aprSocketp;
  268. mPollInfop->mPollFD.client_data = NULL;
  269. F64 mt_sec = getMessageTimeSeconds();
  270. mResendDumpTime = mt_sec;
  271. mMessageCountTime = mt_sec;
  272. mCircuitPrintTime = mt_sec;
  273. mCurrentMessageTimeSeconds = mt_sec;
  274. // Constants for dumping output based on message processing time/count
  275. mNumMessageCounts = 0;
  276. mMaxMessageCounts = 200; // >= 0 means dump warnings
  277. mMaxMessageTime   = 1.f;
  278. mTrueReceiveSize = 0;
  279. mReceiveTime = 0.f;
  280. }
  281. // Read file and build message templates
  282. void LLMessageSystem::loadTemplateFile(const std::string& filename, bool failure_is_fatal)
  283. {
  284. if(filename.empty())
  285. {
  286. LL_ERRS("Messaging") << "No template filename specified" << llendl;
  287. mbError = TRUE;
  288. return;
  289. }
  290. std::string template_body;
  291. if(!_read_file_into_string(template_body, filename))
  292. {
  293. if (failure_is_fatal) {
  294. LL_ERRS("Messaging") << "Failed to open template: " << filename << llendl;
  295. } else {
  296. LL_WARNS("Messaging") << "Failed to open template: " << filename << llendl;
  297. }
  298. mbError = TRUE;
  299. return;
  300. }
  301. LLTemplateTokenizer tokens(template_body);
  302. LLTemplateParser parsed(tokens);
  303. mMessageFileVersionNumber = parsed.getVersion();
  304. for(LLTemplateParser::message_iterator iter = parsed.getMessagesBegin();
  305. iter != parsed.getMessagesEnd();
  306. iter++)
  307. {
  308. addTemplate(*iter);
  309. }
  310. }
  311. LLMessageSystem::~LLMessageSystem()
  312. {
  313. mMessageTemplates.clear(); // don't delete templates.
  314. for_each(mMessageNumbers.begin(), mMessageNumbers.end(), DeletePairedPointer());
  315. mMessageNumbers.clear();
  316. if (!mbError)
  317. {
  318. end_net(mSocket);
  319. }
  320. mSocket = 0;
  321. delete mTemplateMessageReader;
  322. mTemplateMessageReader = NULL;
  323. mMessageReader = NULL;
  324. delete mTemplateMessageBuilder;
  325. mTemplateMessageBuilder = NULL;
  326. mMessageBuilder = NULL;
  327. delete mLLSDMessageReader;
  328. mLLSDMessageReader = NULL;
  329. delete mLLSDMessageBuilder;
  330. mLLSDMessageBuilder = NULL;
  331. delete mPollInfop;
  332. mPollInfop = NULL;
  333. mIncomingCompressedSize = 0;
  334. mCurrentRecvPacketID = 0;
  335. }
  336. void LLMessageSystem::clearReceiveState()
  337. {
  338. mCurrentRecvPacketID = 0;
  339. mIncomingCompressedSize = 0;
  340. mLastSender.invalidate();
  341. mLastReceivingIF.invalidate();
  342. mMessageReader->clearMessage();
  343. mLastMessageFromTrustedMessageService = false;
  344. }
  345. BOOL LLMessageSystem::poll(F32 seconds)
  346. {
  347. S32 num_socks;
  348. apr_status_t status;
  349. status = apr_poll(&(mPollInfop->mPollFD), 1, &num_socks,(U64)(seconds*1000000.f));
  350. if (status != APR_TIMEUP)
  351. {
  352. ll_apr_warn_status(status);
  353. }
  354. if (num_socks)
  355. {
  356. return TRUE;
  357. }
  358. else
  359. {
  360. return FALSE;
  361. }
  362. }
  363. bool LLMessageSystem::isTrustedSender(const LLHost& host) const
  364. {
  365. LLCircuitData* cdp = mCircuitInfo.findCircuit(host);
  366. if(NULL == cdp)
  367. {
  368. return false;
  369. }
  370. return cdp->getTrusted();
  371. }
  372. void LLMessageSystem::receivedMessageFromTrustedSender()
  373. {
  374. mLastMessageFromTrustedMessageService = true;
  375. }
  376. bool LLMessageSystem::isTrustedSender() const
  377. {
  378. return mLastMessageFromTrustedMessageService ||
  379. isTrustedSender(getSender());
  380. }
  381. static LLMessageSystem::message_template_name_map_t::const_iterator 
  382. findTemplate(const LLMessageSystem::message_template_name_map_t& templates, 
  383.  std::string name)
  384. {
  385. const char* namePrehash = LLMessageStringTable::getInstance()->getString(name.c_str());
  386. if(NULL == namePrehash) {return templates.end();}
  387. return templates.find(namePrehash);
  388. }
  389. bool LLMessageSystem::isTrustedMessage(const std::string& name) const
  390. {
  391. message_template_name_map_t::const_iterator iter = 
  392. findTemplate(mMessageTemplates, name);
  393. if(iter == mMessageTemplates.end()) {return false;}
  394. return iter->second->getTrust() == MT_TRUST;
  395. }
  396. bool LLMessageSystem::isUntrustedMessage(const std::string& name) const
  397. {
  398. message_template_name_map_t::const_iterator iter = 
  399. findTemplate(mMessageTemplates, name);
  400. if(iter == mMessageTemplates.end()) {return false;}
  401. return iter->second->getTrust() == MT_NOTRUST;
  402. }
  403. LLCircuitData* LLMessageSystem::findCircuit(const LLHost& host,
  404. bool resetPacketId)
  405. {
  406. LLCircuitData* cdp = mCircuitInfo.findCircuit(host);
  407. if (!cdp)
  408. {
  409. // This packet comes from a circuit we don't know about.
  410. // Are we rejecting off-circuit packets?
  411. if (mbProtected)
  412. {
  413. // cdp is already NULL, so we don't need to unset it.
  414. }
  415. else
  416. {
  417. // nope, open the new circuit
  418. cdp = mCircuitInfo.addCircuitData(host, mCurrentRecvPacketID);
  419. if(resetPacketId)
  420. {
  421. // I added this - I think it's correct - DJS
  422. // reset packet in ID
  423. cdp->setPacketInID(mCurrentRecvPacketID);
  424. }
  425. // And claim the packet is on the circuit we just added.
  426. }
  427. }
  428. else
  429. {
  430. // this is an old circuit. . . is it still alive?
  431. if (!cdp->isAlive())
  432. {
  433. // nope. don't accept if we're protected
  434. if (mbProtected)
  435. {
  436. // don't accept packets from unexpected sources
  437. cdp = NULL;
  438. }
  439. else
  440. {
  441. // wake up the circuit
  442. cdp->setAlive(TRUE);
  443. if(resetPacketId)
  444. {
  445. // reset packet in ID
  446. cdp->setPacketInID(mCurrentRecvPacketID);
  447. }
  448. }
  449. }
  450. }
  451. return cdp;
  452. }
  453. // Returns TRUE if a valid, on-circuit message has been received.
  454. BOOL LLMessageSystem::checkMessages( S64 frame_count )
  455. {
  456. // Pump 
  457. BOOL valid_packet = FALSE;
  458. mMessageReader = mTemplateMessageReader;
  459. LLTransferTargetVFile::updateQueue();
  460. if (!mNumMessageCounts)
  461. {
  462. // This is the first message being handled after a resetReceiveCounts,
  463. // we must be starting the message processing loop.  Reset the timers.
  464. mCurrentMessageTimeSeconds = totalTime() * SEC_PER_USEC;
  465. mMessageCountTime = getMessageTimeSeconds();
  466. }
  467. // loop until either no packets or a valid packet
  468. // i.e., burn through packets from unregistered circuits
  469. S32 receive_size = 0;
  470. do
  471. {
  472. clearReceiveState();
  473. BOOL recv_reliable = FALSE;
  474. BOOL recv_resent = FALSE;
  475. S32 acks = 0;
  476. S32 true_rcv_size = 0;
  477. U8* buffer = mTrueReceiveBuffer;
  478. mTrueReceiveSize = mPacketRing.receivePacket(mSocket, (char *)mTrueReceiveBuffer);
  479. // If you want to dump all received packets into SecondLife.log, uncomment this
  480. //dumpPacketToLog();
  481. receive_size = mTrueReceiveSize;
  482. mLastSender = mPacketRing.getLastSender();
  483. mLastReceivingIF = mPacketRing.getLastReceivingInterface();
  484. if (receive_size < (S32) LL_MINIMUM_VALID_PACKET_SIZE)
  485. {
  486. // A receive size of zero is OK, that means that there are no more packets available.
  487. // Ones that are non-zero but below the minimum packet size are worrisome.
  488. if (receive_size > 0)
  489. {
  490. LL_WARNS("Messaging") << "Invalid (too short) packet discarded " << receive_size << llendl;
  491. callExceptionFunc(MX_PACKET_TOO_SHORT);
  492. }
  493. // no data in packet receive buffer
  494. valid_packet = FALSE;
  495. }
  496. else
  497. {
  498. LLHost host;
  499. LLCircuitData* cdp;
  500. // note if packet acks are appended.
  501. if(buffer[0] & LL_ACK_FLAG)
  502. {
  503. acks += buffer[--receive_size];
  504. true_rcv_size = receive_size;
  505. if(receive_size >= ((S32)(acks * sizeof(TPACKETID) + LL_MINIMUM_VALID_PACKET_SIZE)))
  506. {
  507. receive_size -= acks * sizeof(TPACKETID);
  508. }
  509. else
  510. {
  511. // mal-formed packet. ignore it and continue with
  512. // the next one
  513. LL_WARNS("Messaging") << "Malformed packet received. Packet size "
  514. << receive_size << " with invalid no. of acks " << acks
  515. << llendl;
  516. valid_packet = FALSE;
  517. continue;
  518. }
  519. }
  520. // process the message as normal
  521. mIncomingCompressedSize = zeroCodeExpand(&buffer, &receive_size);
  522. mCurrentRecvPacketID = ntohl(*((U32*)(&buffer[1])));
  523. host = getSender();
  524. const bool resetPacketId = true;
  525. cdp = findCircuit(host, resetPacketId);
  526. // At this point, cdp is now a pointer to the circuit that
  527. // this message came in on if it's valid, and NULL if the
  528. // circuit was bogus.
  529. if(cdp && (acks > 0) && ((S32)(acks * sizeof(TPACKETID)) < (true_rcv_size)))
  530. {
  531. TPACKETID packet_id;
  532. U32 mem_id=0;
  533. for(S32 i = 0; i < acks; ++i)
  534. {
  535. true_rcv_size -= sizeof(TPACKETID);
  536. memcpy(&mem_id, &mTrueReceiveBuffer[true_rcv_size], /* Flawfinder: ignore*/
  537.      sizeof(TPACKETID));
  538. packet_id = ntohl(mem_id);
  539. //LL_INFOS("Messaging") << "got ack: " << packet_id << llendl;
  540. cdp->ackReliablePacket(packet_id);
  541. }
  542. if (!cdp->getUnackedPacketCount())
  543. {
  544. // Remove this circuit from the list of circuits with unacked packets
  545. mCircuitInfo.mUnackedCircuitMap.erase(cdp->mHost);
  546. }
  547. }
  548. if (buffer[0] & LL_RELIABLE_FLAG)
  549. {
  550. recv_reliable = TRUE;
  551. }
  552. if (buffer[0] & LL_RESENT_FLAG)
  553. {
  554. recv_resent = TRUE;
  555. if (cdp && cdp->isDuplicateResend(mCurrentRecvPacketID))
  556. {
  557. // We need to ACK here to suppress
  558. // further resends of packets we've
  559. // already seen.
  560. if (recv_reliable)
  561. {
  562. //mAckList.addData(new LLPacketAck(host, mCurrentRecvPacketID));
  563. // ***************************************
  564. // TESTING CODE
  565. //if(mCircuitInfo.mCurrentCircuit->mHost != host)
  566. //{
  567. // LL_WARNS("Messaging") << "DISCARDED PACKET HOST MISMATCH! HOST: "
  568. // << host << " CIRCUIT: "
  569. // << mCircuitInfo.mCurrentCircuit->mHost
  570. // << llendl;
  571. //}
  572. // ***************************************
  573. //mCircuitInfo.mCurrentCircuit->mAcks.put(mCurrentRecvPacketID);
  574. cdp->collectRAck(mCurrentRecvPacketID);
  575. }
  576.  
  577. LL_DEBUGS("Messaging") << "Discarding duplicate resend from " << host << llendl;
  578. if(mVerboseLog)
  579. {
  580. std::ostringstream str;
  581. str << "MSG: <- " << host;
  582. std::string tbuf;
  583. tbuf = llformat( "t%6dt%6dt%6d ", receive_size, (mIncomingCompressedSize ? mIncomingCompressedSize : receive_size), mCurrentRecvPacketID);
  584. str << tbuf << "(unknown)"
  585. << (recv_reliable ? " reliable" : "")
  586. << " resent "
  587. << ((acks > 0) ? "acks" : "")
  588. << " DISCARD DUPLICATE";
  589. LL_INFOS("Messaging") << str.str() << llendl;
  590. }
  591. mPacketsIn++;
  592. valid_packet = FALSE;
  593. continue;
  594. }
  595. }
  596. // UseCircuitCode can be a valid, off-circuit packet.
  597. // But we don't want to acknowledge UseCircuitCode until the circuit is
  598. // available, which is why the acknowledgement test is done above.  JC
  599. bool trusted = cdp && cdp->getTrusted();
  600. valid_packet = mTemplateMessageReader->validateMessage(
  601. buffer,
  602. receive_size,
  603. host,
  604. trusted);
  605. if (!valid_packet)
  606. {
  607. clearReceiveState();
  608. }
  609. // UseCircuitCode is allowed in even from an invalid circuit, so that
  610. // we can toss circuits around.
  611. if(
  612. valid_packet &&
  613. !cdp && 
  614. (mTemplateMessageReader->getMessageName() !=
  615.  _PREHASH_UseCircuitCode))
  616. {
  617. logMsgFromInvalidCircuit( host, recv_reliable );
  618. clearReceiveState();
  619. valid_packet = FALSE;
  620. }
  621. if(
  622. valid_packet &&
  623. cdp &&
  624. !cdp->getTrusted() && 
  625. mTemplateMessageReader->isTrusted())
  626. {
  627. logTrustedMsgFromUntrustedCircuit( host );
  628. clearReceiveState();
  629. sendDenyTrustedCircuit(host);
  630. valid_packet = FALSE;
  631. }
  632. if( valid_packet )
  633. {
  634. logValidMsg(cdp, host, recv_reliable, recv_resent, (BOOL)(acks>0) );
  635. valid_packet = mTemplateMessageReader->readMessage(buffer, host);
  636. }
  637. // It's possible that the circuit went away, because ANY message can disable the circuit
  638. // (for example, UseCircuit, CloseCircuit, DisableSimulator).  Find it again.
  639. cdp = mCircuitInfo.findCircuit(host);
  640. if (valid_packet)
  641. {
  642. mPacketsIn++;
  643. mBytesIn += mTrueReceiveSize;
  644. // ACK here for valid packets that we've seen
  645. // for the first time.
  646. if (cdp && recv_reliable)
  647. {
  648. // Add to the recently received list for duplicate suppression
  649. cdp->mRecentlyReceivedReliablePackets[mCurrentRecvPacketID] = getMessageTimeUsecs();
  650. // Put it onto the list of packets to be acked
  651. cdp->collectRAck(mCurrentRecvPacketID);
  652. mReliablePacketsIn++;
  653. }
  654. }
  655. else
  656. {
  657. if (mbProtected  && (!cdp))
  658. {
  659. LL_WARNS("Messaging") << "Invalid Packet from invalid circuit " << host << llendl;
  660. mOffCircuitPackets++;
  661. }
  662. else
  663. {
  664. mInvalidOnCircuitPackets++;
  665. }
  666. }
  667. }
  668. } while (!valid_packet && receive_size > 0);
  669. F64 mt_sec = getMessageTimeSeconds();
  670. // Check to see if we need to print debug info
  671. if ((mt_sec - mCircuitPrintTime) > mCircuitPrintFreq)
  672. {
  673. dumpCircuitInfo();
  674. mCircuitPrintTime = mt_sec;
  675. }
  676. if( !valid_packet )
  677. {
  678. clearReceiveState();
  679. }
  680. return valid_packet;
  681. }
  682. S32 LLMessageSystem::getReceiveBytes() const
  683. {
  684. if (getReceiveCompressedSize())
  685. {
  686. return getReceiveCompressedSize() * 8;
  687. }
  688. else
  689. {
  690. return getReceiveSize() * 8;
  691. }
  692. }
  693. void LLMessageSystem::processAcks()
  694. {
  695. LLMemType mt_pa(LLMemType::MTYPE_MESSAGE_PROCESS_ACKS);
  696. F64 mt_sec = getMessageTimeSeconds();
  697. {
  698. gTransferManager.updateTransfers();
  699. if (gXferManager)
  700. {
  701. gXferManager->retransmitUnackedPackets();
  702. }
  703. if (gAssetStorage)
  704. {
  705. gAssetStorage->checkForTimeouts();
  706. }
  707. }
  708. BOOL dump = FALSE;
  709. {
  710. // Check the status of circuits
  711. mCircuitInfo.updateWatchDogTimers(this);
  712. //resend any necessary packets
  713. mCircuitInfo.resendUnackedPackets(mUnackedListDepth, mUnackedListSize);
  714. //cycle through ack list for each host we need to send acks to
  715. mCircuitInfo.sendAcks();
  716. if (!mDenyTrustedCircuitSet.empty())
  717. {
  718. LL_INFOS("Messaging") << "Sending queued DenyTrustedCircuit messages." << llendl;
  719. for (host_set_t::iterator hostit = mDenyTrustedCircuitSet.begin(); hostit != mDenyTrustedCircuitSet.end(); ++hostit)
  720. {
  721. reallySendDenyTrustedCircuit(*hostit);
  722. }
  723. mDenyTrustedCircuitSet.clear();
  724. }
  725. if (mMaxMessageCounts >= 0)
  726. {
  727. if (mNumMessageCounts >= mMaxMessageCounts)
  728. {
  729. dump = TRUE;
  730. }
  731. }
  732. if (mMaxMessageTime >= 0.f)
  733. {
  734. // This is one of the only places where we're required to get REAL message system time.
  735. mReceiveTime = (F32)(getMessageTimeSeconds(TRUE) - mMessageCountTime);
  736. if (mReceiveTime > mMaxMessageTime)
  737. {
  738. dump = TRUE;
  739. }
  740. }
  741. }
  742. if (dump)
  743. {
  744. dumpReceiveCounts();
  745. }
  746. resetReceiveCounts();
  747. if ((mt_sec - mResendDumpTime) > CIRCUIT_DUMP_TIMEOUT)
  748. {
  749. mResendDumpTime = mt_sec;
  750. mCircuitInfo.dumpResends();
  751. }
  752. }
  753. void LLMessageSystem::copyMessageReceivedToSend()
  754. {
  755. // NOTE: babbage: switch builder to match reader to avoid
  756. // converting message format
  757. if(mMessageReader == mTemplateMessageReader)
  758. {
  759. mMessageBuilder = mTemplateMessageBuilder;
  760. }
  761. else
  762. {
  763. mMessageBuilder = mLLSDMessageBuilder;
  764. }
  765. mSendReliable = FALSE;
  766. mMessageBuilder->newMessage(mMessageReader->getMessageName());
  767. mMessageReader->copyToBuilder(*mMessageBuilder);
  768. }
  769. LLSD LLMessageSystem::getReceivedMessageLLSD() const
  770. {
  771. LLSDMessageBuilder builder;
  772. mMessageReader->copyToBuilder(builder);
  773. return builder.getMessage();
  774. }
  775. LLSD LLMessageSystem::getBuiltMessageLLSD() const 
  776. {
  777. LLSD result;
  778. if (mLLSDMessageBuilder == mMessageBuilder)
  779. {
  780.  result = mLLSDMessageBuilder->getMessage();
  781. }
  782. else
  783. {
  784. // TODO: implement as below?
  785. llerrs << "Message not built as LLSD." << llendl; 
  786. }
  787. return result;
  788. }
  789. LLSD LLMessageSystem::wrapReceivedTemplateData() const
  790. {
  791. if(mMessageReader == mTemplateMessageReader)
  792. {
  793. LLTemplateMessageBuilder builder(mMessageTemplates);
  794. builder.newMessage(mMessageReader->getMessageName());
  795. mMessageReader->copyToBuilder(builder);
  796. U8 buffer[MAX_BUFFER_SIZE];
  797. const U8 offset_to_data = 0;
  798. U32 size = builder.buildMessage(buffer, MAX_BUFFER_SIZE,
  799. offset_to_data);
  800. std::vector<U8> binary_data(buffer, buffer+size);
  801. LLSD wrapped_data = LLSD::emptyMap();
  802. wrapped_data["binary-template-data"] = binary_data;
  803. return wrapped_data;
  804. }
  805. else
  806. {
  807. return getReceivedMessageLLSD();
  808. }
  809. }
  810. LLSD LLMessageSystem::wrapBuiltTemplateData() const
  811. {
  812. LLSD result;
  813. if (mLLSDMessageBuilder == mMessageBuilder)
  814. {
  815. result = getBuiltMessageLLSD();
  816. }
  817. else
  818. {
  819. U8 buffer[MAX_BUFFER_SIZE];
  820. const U8 offset_to_data = 0;
  821. U32 size = mTemplateMessageBuilder->buildMessage(
  822. buffer, MAX_BUFFER_SIZE,
  823. offset_to_data);
  824. std::vector<U8> binary_data(buffer, buffer+size);
  825. LLSD wrapped_data = LLSD::emptyMap();
  826. wrapped_data["binary-template-data"] = binary_data;
  827. result = wrapped_data;
  828. }
  829. return result;
  830. }
  831. LLStoredMessagePtr LLMessageSystem::getReceivedMessage() const
  832. {
  833. const std::string& name = mMessageReader->getMessageName();
  834. LLSD message = wrapReceivedTemplateData();
  835. return LLStoredMessagePtr(new LLStoredMessage(name, message));
  836. }
  837. LLStoredMessagePtr LLMessageSystem::getBuiltMessage() const
  838. {
  839. const std::string& name = mMessageBuilder->getMessageName();
  840. LLSD message = wrapBuiltTemplateData();
  841. return LLStoredMessagePtr(new LLStoredMessage(name, message));
  842. }
  843. S32 LLMessageSystem::sendMessage(const LLHost &host, LLStoredMessagePtr message)
  844. {
  845. return sendMessage(host, message->mName.c_str(), message->mMessage);
  846. }
  847. void LLMessageSystem::clearMessage()
  848. {
  849. mSendReliable = FALSE;
  850. mMessageBuilder->clearMessage();
  851. }
  852. // set block to add data to within current message
  853. void LLMessageSystem::nextBlockFast(const char *blockname)
  854. {
  855. mMessageBuilder->nextBlock(blockname);
  856. }
  857. void LLMessageSystem::nextBlock(const char *blockname)
  858. {
  859. nextBlockFast(LLMessageStringTable::getInstance()->getString(blockname));
  860. }
  861. BOOL LLMessageSystem::isSendFull(const char* blockname)
  862. {
  863. char* stringTableName = NULL;
  864. if(NULL != blockname)
  865. {
  866. stringTableName = LLMessageStringTable::getInstance()->getString(blockname);
  867. }
  868. return isSendFullFast(stringTableName);
  869. }
  870. BOOL LLMessageSystem::isSendFullFast(const char* blockname)
  871. {
  872. return mMessageBuilder->isMessageFull(blockname);
  873. }
  874. // blow away the last block of a message, return FALSE if that leaves no blocks or there wasn't a block to remove
  875. // TODO: Babbage: Remove this horror.
  876. BOOL LLMessageSystem::removeLastBlock()
  877. {
  878. return mMessageBuilder->removeLastBlock();
  879. }
  880. S32 LLMessageSystem::sendReliable(const LLHost &host)
  881. {
  882. return sendReliable(host, LL_DEFAULT_RELIABLE_RETRIES, TRUE, LL_PING_BASED_TIMEOUT_DUMMY, NULL, NULL);
  883. }
  884. S32 LLMessageSystem::sendSemiReliable(const LLHost &host, void (*callback)(void **,S32), void ** callback_data)
  885. {
  886. F32 timeout;
  887. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  888. if (cdp)
  889. {
  890. timeout = llmax(LL_MINIMUM_SEMIRELIABLE_TIMEOUT_SECONDS,
  891. LL_SEMIRELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged());
  892. }
  893. else
  894. {
  895. timeout = LL_SEMIRELIABLE_TIMEOUT_FACTOR * LL_AVERAGED_PING_MAX;
  896. }
  897. const S32 retries = 0;
  898. const BOOL ping_based_timeout = FALSE;
  899. return sendReliable(host, retries, ping_based_timeout, timeout, callback, callback_data);
  900. }
  901. // send the message via a UDP packet
  902. S32 LLMessageSystem::sendReliable( const LLHost &host, 
  903. S32 retries, 
  904. BOOL ping_based_timeout,
  905. F32 timeout, 
  906. void (*callback)(void **,S32), 
  907. void ** callback_data)
  908. {
  909. if (ping_based_timeout)
  910. {
  911.     LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  912.     if (cdp)
  913.     {
  914.     timeout = llmax(LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS, LL_RELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged());
  915.     }
  916.     else
  917.     {
  918.     timeout = llmax(LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS, LL_RELIABLE_TIMEOUT_FACTOR * LL_AVERAGED_PING_MAX);
  919.     }
  920. }
  921. mSendReliable = TRUE;
  922. mReliablePacketParams.set(host, retries, ping_based_timeout, timeout, 
  923. callback, callback_data, 
  924. const_cast<char*>(mMessageBuilder->getMessageName()));
  925. return sendMessage(host);
  926. }
  927. void LLMessageSystem::forwardMessage(const LLHost &host)
  928. {
  929. copyMessageReceivedToSend();
  930. sendMessage(host);
  931. }
  932. void LLMessageSystem::forwardReliable(const LLHost &host)
  933. {
  934. copyMessageReceivedToSend();
  935. sendReliable(host);
  936. }
  937. void LLMessageSystem::forwardReliable(const U32 circuit_code)
  938. {
  939. copyMessageReceivedToSend();
  940. sendReliable(findHost(circuit_code));
  941. }
  942. S32 LLMessageSystem::forwardReliable( const LLHost &host, 
  943. S32 retries, 
  944. BOOL ping_based_timeout,
  945. F32 timeout, 
  946. void (*callback)(void **,S32), 
  947. void ** callback_data)
  948. {
  949. copyMessageReceivedToSend();
  950. return sendReliable(host, retries, ping_based_timeout, timeout, callback, callback_data);
  951. }
  952. S32 LLMessageSystem::flushSemiReliable(const LLHost &host, void (*callback)(void **,S32), void ** callback_data)
  953. {
  954. F32 timeout; 
  955. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  956. if (cdp)
  957. {
  958. timeout = llmax(LL_MINIMUM_SEMIRELIABLE_TIMEOUT_SECONDS,
  959. LL_SEMIRELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged());
  960. }
  961. else
  962. {
  963. timeout = LL_SEMIRELIABLE_TIMEOUT_FACTOR * LL_AVERAGED_PING_MAX;
  964. }
  965. S32 send_bytes = 0;
  966. if (mMessageBuilder->getMessageSize())
  967. {
  968. mSendReliable = TRUE;
  969. // No need for ping-based retry as not going to retry
  970. mReliablePacketParams.set(host, 0, FALSE, timeout, callback, 
  971.   callback_data, 
  972.   const_cast<char*>(mMessageBuilder->getMessageName()));
  973. send_bytes = sendMessage(host);
  974. clearMessage();
  975. }
  976. else
  977. {
  978. delete callback_data;
  979. }
  980. return send_bytes;
  981. }
  982. S32 LLMessageSystem::flushReliable(const LLHost &host)
  983. {
  984. S32 send_bytes = 0;
  985. if (mMessageBuilder->getMessageSize())
  986. {
  987. send_bytes = sendReliable(host);
  988. }
  989. clearMessage();
  990. return send_bytes;
  991. }
  992. LLHTTPClient::ResponderPtr LLMessageSystem::createResponder(const std::string& name)
  993. {
  994. if(mSendReliable)
  995. {
  996. return new LLFnPtrResponder(
  997. mReliablePacketParams.mCallback,
  998. mReliablePacketParams.mCallbackData,
  999. name);
  1000. }
  1001. else
  1002. {
  1003. // These messages aren't really unreliable, they just weren't
  1004. // explicitly sent as reliable, so they don't have a callback
  1005. // LL_WARNS("Messaging") << "LLMessageSystem::sendMessage: Sending unreliable "
  1006. // << mMessageBuilder->getMessageName() << " message via HTTP"
  1007. // << llendl;
  1008. return new LLFnPtrResponder(
  1009. NULL,
  1010. NULL,
  1011. name);
  1012. }
  1013. }
  1014. // This can be called from signal handlers,
  1015. // so should should not use llinfos.
  1016. S32 LLMessageSystem::sendMessage(const LLHost &host)
  1017. {
  1018. if (! mMessageBuilder->isBuilt())
  1019. {
  1020. mSendSize = mMessageBuilder->buildMessage(
  1021. mSendBuffer,
  1022. MAX_BUFFER_SIZE,
  1023. 0);
  1024. }
  1025. if (!(host.isOk()))    // if port and ip are zero, don't bother trying to send the message
  1026. {
  1027. return 0;
  1028. }
  1029. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  1030. if (!cdp)
  1031. {
  1032. // this is a new circuit!
  1033. // are we protected?
  1034. if (mbProtected)
  1035. {
  1036. // yup! don't send packets to an unknown circuit
  1037. if(mVerboseLog)
  1038. {
  1039. LL_INFOS_ONCE("Messaging") << "MSG: -> " << host << "tUNKNOWN CIRCUIT:t"
  1040. << mMessageBuilder->getMessageName() << llendl;
  1041. }
  1042. LL_WARNS_ONCE("Messaging") << "sendMessage - Trying to send "
  1043. << mMessageBuilder->getMessageName() << " on unknown circuit "
  1044. << host << llendl;
  1045. return 0;
  1046. }
  1047. else
  1048. {
  1049. // nope, open the new circuit
  1050. cdp = mCircuitInfo.addCircuitData(host, 0);
  1051. }
  1052. }
  1053. else
  1054. {
  1055. // this is an old circuit. . . is it still alive?
  1056. if (!cdp->isAlive())
  1057. {
  1058. // nope. don't send to dead circuits
  1059. if(mVerboseLog)
  1060. {
  1061. LL_INFOS("Messaging") << "MSG: -> " << host << "tDEAD CIRCUITtt"
  1062. << mMessageBuilder->getMessageName() << llendl;
  1063. }
  1064. LL_WARNS("Messaging") << "sendMessage - Trying to send message "
  1065. << mMessageBuilder->getMessageName() << " to dead circuit "
  1066. << host << llendl;
  1067. return 0;
  1068. }
  1069. }
  1070. // NOTE: babbage: LLSD message -> HTTP, template message -> UDP
  1071. if(mMessageBuilder == mLLSDMessageBuilder)
  1072. {
  1073. LLSD message = mLLSDMessageBuilder->getMessage();
  1074. const LLHTTPSender& sender = LLHTTPSender::getSender(host);
  1075. sender.send(
  1076. host,
  1077. mLLSDMessageBuilder->getMessageName(),
  1078. message,
  1079. createResponder(mLLSDMessageBuilder->getMessageName()));
  1080. mSendReliable = FALSE;
  1081. mReliablePacketParams.clear();
  1082. return 1;
  1083. }
  1084. // zero out the flags and packetid. Subtract 1 here so that we do
  1085. // not overwrite the offset if it was set set in buildMessage().
  1086. memset(mSendBuffer, 0, LL_PACKET_ID_SIZE - 1); 
  1087. // add the send id to the front of the message
  1088. cdp->nextPacketOutID();
  1089. // Packet ID size is always 4
  1090. *((S32*)&mSendBuffer[PHL_PACKET_ID]) = htonl(cdp->getPacketOutID());
  1091. // Compress the message, which will usually reduce its size.
  1092. U8 * buf_ptr = (U8 *)mSendBuffer;
  1093. U32 buffer_length = mSendSize;
  1094. mMessageBuilder->compressMessage(buf_ptr, buffer_length);
  1095. if (buffer_length > 1500)
  1096. {
  1097. if((mMessageBuilder->getMessageName() != _PREHASH_ChildAgentUpdate)
  1098.    && (mMessageBuilder->getMessageName() != _PREHASH_SendXferPacket))
  1099. {
  1100. LL_WARNS("Messaging") << "sendMessage - Trying to send "
  1101. << ((buffer_length > 4000) ? "EXTRA " : "")
  1102. << "BIG message " << mMessageBuilder->getMessageName() << " - "
  1103. << buffer_length << llendl;
  1104. }
  1105. }
  1106. if (mSendReliable)
  1107. {
  1108. buf_ptr[0] |= LL_RELIABLE_FLAG;
  1109. if (!cdp->getUnackedPacketCount())
  1110. {
  1111. // We are adding the first packed onto the unacked packet list(s)
  1112. // Add this circuit to the list of circuits with unacked packets
  1113. mCircuitInfo.mUnackedCircuitMap[cdp->mHost] = cdp;
  1114. }
  1115. cdp->addReliablePacket(mSocket,buf_ptr,buffer_length, &mReliablePacketParams);
  1116. mReliablePacketsOut++;
  1117. }
  1118. // tack packet acks onto the end of this message
  1119. S32 space_left = (MTUBYTES - buffer_length) / sizeof(TPACKETID); // space left for packet ids
  1120. S32 ack_count = (S32)cdp->mAcks.size();
  1121. BOOL is_ack_appended = FALSE;
  1122. std::vector<TPACKETID> acks;
  1123. if((space_left > 0) && (ack_count > 0) && 
  1124.    (mMessageBuilder->getMessageName() != _PREHASH_PacketAck))
  1125. {
  1126. buf_ptr[0] |= LL_ACK_FLAG;
  1127. S32 append_ack_count = llmin(space_left, ack_count);
  1128. const S32 MAX_ACKS = 250;
  1129. append_ack_count = llmin(append_ack_count, MAX_ACKS);
  1130. std::vector<TPACKETID>::iterator iter = cdp->mAcks.begin();
  1131. std::vector<TPACKETID>::iterator last = cdp->mAcks.begin();
  1132. last += append_ack_count;
  1133. TPACKETID packet_id;
  1134. for( ; iter != last ; ++iter)
  1135. {
  1136. // grab the next packet id.
  1137. packet_id = (*iter);
  1138. if(mVerboseLog)
  1139. {
  1140. acks.push_back(packet_id);
  1141. }
  1142. // put it on the end of the buffer
  1143. packet_id = htonl(packet_id);
  1144. if((S32)(buffer_length + sizeof(TPACKETID)) < MAX_BUFFER_SIZE)
  1145. {
  1146.     memcpy(&buf_ptr[buffer_length], &packet_id, sizeof(TPACKETID)); /* Flawfinder: ignore */
  1147.     // Do the accounting
  1148.     buffer_length += sizeof(TPACKETID);
  1149. }
  1150. else
  1151. {
  1152.     // Just reporting error is likely not enough.  Need to
  1153.     // check how to abort or error out gracefully from
  1154.     // this function. XXXTBD
  1155. // *NOTE: Actually hitting this error would indicate
  1156. // the calculation above for space_left, ack_count,
  1157. // append_acout_count is incorrect or that
  1158. // MAX_BUFFER_SIZE has fallen below MTU which is bad
  1159. // and probably programmer error.
  1160.     LL_ERRS("Messaging") << "Buffer packing failed due to size.." << llendl;
  1161. }
  1162. }
  1163. // clean up the source
  1164. cdp->mAcks.erase(cdp->mAcks.begin(), last);
  1165. // tack the count in the final byte
  1166. U8 count = (U8)append_ack_count;
  1167. buf_ptr[buffer_length++] = count;
  1168. is_ack_appended = TRUE;
  1169. }
  1170. BOOL success;
  1171. success = mPacketRing.sendPacket(mSocket, (char *)buf_ptr, buffer_length, host);
  1172. if (!success)
  1173. {
  1174. mSendPacketFailureCount++;
  1175. }
  1176. else
  1177. {
  1178. // mCircuitInfo already points to the correct circuit data
  1179. cdp->addBytesOut( buffer_length );
  1180. }
  1181. if(mVerboseLog)
  1182. {
  1183. std::ostringstream str;
  1184. str << "MSG: -> " << host;
  1185. std::string buffer;
  1186. buffer = llformat( "t%6dt%6dt%6d ", mSendSize, buffer_length, cdp->getPacketOutID());
  1187. str << buffer
  1188. << mMessageBuilder->getMessageName()
  1189. << (mSendReliable ? " reliable " : "");
  1190. if(is_ack_appended)
  1191. {
  1192. str << "tACKS:t";
  1193. std::ostream_iterator<TPACKETID> append(str, " ");
  1194. std::copy(acks.begin(), acks.end(), append);
  1195. }
  1196. LL_INFOS("Messaging") << str.str() << llendl;
  1197. }
  1198. mPacketsOut++;
  1199. mBytesOut += buffer_length;
  1200. mSendReliable = FALSE;
  1201. mReliablePacketParams.clear();
  1202. return buffer_length;
  1203. }
  1204. void LLMessageSystem::logMsgFromInvalidCircuit( const LLHost& host, BOOL recv_reliable )
  1205. {
  1206. if(mVerboseLog)
  1207. {
  1208. std::ostringstream str;
  1209. str << "MSG: <- " << host;
  1210. std::string buffer;
  1211. buffer = llformat( "t%6dt%6dt%6d ", mMessageReader->getMessageSize(), (mIncomingCompressedSize ? mIncomingCompressedSize: mMessageReader->getMessageSize()), mCurrentRecvPacketID);
  1212. str << buffer
  1213. << nullToEmpty(mMessageReader->getMessageName())
  1214. << (recv_reliable ? " reliable" : "")
  1215.   << " REJECTED";
  1216. LL_INFOS("Messaging") << str.str() << llendl;
  1217. }
  1218. // nope!
  1219. // cout << "Rejecting unexpected message " << mCurrentMessageTemplate->mName << " from " << hex << ip << " , " << dec << port << endl;
  1220. // Keep track of rejected messages as well
  1221. if (mNumMessageCounts >= MAX_MESSAGE_COUNT_NUM)
  1222. {
  1223. LL_WARNS("Messaging") << "Got more than " << MAX_MESSAGE_COUNT_NUM << " packets without clearing counts" << llendl;
  1224. }
  1225. else
  1226. {
  1227. // TODO: babbage: work out if we need these
  1228. // mMessageCountList[mNumMessageCounts].mMessageNum = mCurrentRMessageTemplate->mMessageNumber;
  1229. mMessageCountList[mNumMessageCounts].mMessageBytes = mMessageReader->getMessageSize();
  1230. mMessageCountList[mNumMessageCounts].mInvalid = TRUE;
  1231. mNumMessageCounts++;
  1232. }
  1233. }
  1234. S32 LLMessageSystem::sendMessage(
  1235. const LLHost &host,
  1236. const char* name,
  1237. const LLSD& message)
  1238. {
  1239. if (!(host.isOk()))
  1240. {
  1241. LL_WARNS("Messaging") << "trying to send message to invalid host" << llendl;
  1242. return 0;
  1243. }
  1244. const LLHTTPSender& sender = LLHTTPSender::getSender(host);
  1245. sender.send(host, name, message, createResponder(name));
  1246. return 1;
  1247. }
  1248. void LLMessageSystem::logTrustedMsgFromUntrustedCircuit( const LLHost& host )
  1249. {
  1250. // RequestTrustedCircuit is how we establish trust, so don't spam
  1251. // if it's received on a trusted circuit. JC
  1252. if (strcmp(mMessageReader->getMessageName(), "RequestTrustedCircuit"))
  1253. {
  1254. LL_WARNS("Messaging") << "Received trusted message on untrusted circuit. "
  1255. << "Will reply with deny. "
  1256. << "Message: " << nullToEmpty(mMessageReader->getMessageName())
  1257. << " Host: " << host << llendl;
  1258. }
  1259. if (mNumMessageCounts >= MAX_MESSAGE_COUNT_NUM)
  1260. {
  1261. LL_WARNS("Messaging") << "got more than " << MAX_MESSAGE_COUNT_NUM
  1262. << " packets without clearing counts"
  1263. << llendl;
  1264. }
  1265. else
  1266. {
  1267. // TODO: babbage: work out if we need these
  1268. //mMessageCountList[mNumMessageCounts].mMessageNum
  1269. // = mCurrentRMessageTemplate->mMessageNumber;
  1270. mMessageCountList[mNumMessageCounts].mMessageBytes
  1271. = mMessageReader->getMessageSize();
  1272. mMessageCountList[mNumMessageCounts].mInvalid = TRUE;
  1273. mNumMessageCounts++;
  1274. }
  1275. }
  1276. void LLMessageSystem::logValidMsg(LLCircuitData *cdp, const LLHost& host, BOOL recv_reliable, BOOL recv_resent, BOOL recv_acks )
  1277. {
  1278. if (mNumMessageCounts >= MAX_MESSAGE_COUNT_NUM)
  1279. {
  1280. LL_WARNS("Messaging") << "Got more than " << MAX_MESSAGE_COUNT_NUM << " packets without clearing counts" << llendl;
  1281. }
  1282. else
  1283. {
  1284. // TODO: babbage: work out if we need these
  1285. //mMessageCountList[mNumMessageCounts].mMessageNum = mCurrentRMessageTemplate->mMessageNumber;
  1286. mMessageCountList[mNumMessageCounts].mMessageBytes = mMessageReader->getMessageSize();
  1287. mMessageCountList[mNumMessageCounts].mInvalid = FALSE;
  1288. mNumMessageCounts++;
  1289. }
  1290. if (cdp)
  1291. {
  1292. // update circuit packet ID tracking (missing/out of order packets)
  1293. cdp->checkPacketInID( mCurrentRecvPacketID, recv_resent );
  1294. cdp->addBytesIn( mTrueReceiveSize );
  1295. }
  1296. if(mVerboseLog)
  1297. {
  1298. std::ostringstream str;
  1299. str << "MSG: <- " << host;
  1300. std::string buffer;
  1301. buffer = llformat( "t%6dt%6dt%6d ", mMessageReader->getMessageSize(), (mIncomingCompressedSize ? mIncomingCompressedSize : mMessageReader->getMessageSize()), mCurrentRecvPacketID);
  1302. str << buffer
  1303. << nullToEmpty(mMessageReader->getMessageName())
  1304. << (recv_reliable ? " reliable" : "")
  1305. << (recv_resent ? " resent" : "")
  1306. << (recv_acks ? " acks" : "");
  1307. LL_INFOS("Messaging") << str.str() << llendl;
  1308. }
  1309. }
  1310. void LLMessageSystem::sanityCheck()
  1311. {
  1312. // TODO: babbage: reinstate
  1313. // if (!mCurrentRMessageData)
  1314. // {
  1315. // LL_ERRS("Messaging") << "mCurrentRMessageData is NULL" << llendl;
  1316. // }
  1317. // if (!mCurrentRMessageTemplate)
  1318. // {
  1319. // LL_ERRS("Messaging") << "mCurrentRMessageTemplate is NULL" << llendl;
  1320. // }
  1321. // if (!mCurrentRTemplateBlock)
  1322. // {
  1323. // LL_ERRS("Messaging") << "mCurrentRTemplateBlock is NULL" << llendl;
  1324. // }
  1325. // if (!mCurrentRDataBlock)
  1326. // {
  1327. // LL_ERRS("Messaging") << "mCurrentRDataBlock is NULL" << llendl;
  1328. // }
  1329. // if (!mCurrentSMessageData)
  1330. // {
  1331. // LL_ERRS("Messaging") << "mCurrentSMessageData is NULL" << llendl;
  1332. // }
  1333. // if (!mCurrentSMessageTemplate)
  1334. // {
  1335. // LL_ERRS("Messaging") << "mCurrentSMessageTemplate is NULL" << llendl;
  1336. // }
  1337. // if (!mCurrentSTemplateBlock)
  1338. // {
  1339. // LL_ERRS("Messaging") << "mCurrentSTemplateBlock is NULL" << llendl;
  1340. // }
  1341. // if (!mCurrentSDataBlock)
  1342. // {
  1343. // LL_ERRS("Messaging") << "mCurrentSDataBlock is NULL" << llendl;
  1344. // }
  1345. }
  1346. void LLMessageSystem::showCircuitInfo()
  1347. {
  1348. LL_INFOS("Messaging") << mCircuitInfo << llendl;
  1349. }
  1350. void LLMessageSystem::dumpCircuitInfo()
  1351. {
  1352. lldebugst(LLERR_CIRCUIT_INFO) << mCircuitInfo << llendl;
  1353. }
  1354. /* virtual */
  1355. U32 LLMessageSystem::getOurCircuitCode()
  1356. {
  1357. return mOurCircuitCode;
  1358. }
  1359. void LLMessageSystem::getCircuitInfo(LLSD& info) const
  1360. {
  1361. mCircuitInfo.getInfo(info);
  1362. }
  1363. // returns whether the given host is on a trusted circuit
  1364. BOOL    LLMessageSystem::getCircuitTrust(const LLHost &host)
  1365. {
  1366. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  1367. if (cdp)
  1368. {
  1369. return cdp->getTrusted();
  1370. }
  1371. return FALSE;
  1372. }
  1373. // Activate a circuit, and set its trust level (TRUE if trusted,
  1374. // FALSE if not).
  1375. void LLMessageSystem::enableCircuit(const LLHost &host, BOOL trusted)
  1376. {
  1377. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  1378. if (!cdp)
  1379. {
  1380. cdp = mCircuitInfo.addCircuitData(host, 0);
  1381. }
  1382. else
  1383. {
  1384. cdp->setAlive(TRUE);
  1385. }
  1386. cdp->setTrusted(trusted);
  1387. }
  1388. void LLMessageSystem::disableCircuit(const LLHost &host)
  1389. {
  1390. LL_INFOS("Messaging") << "LLMessageSystem::disableCircuit for " << host << llendl;
  1391. U32 code = gMessageSystem->findCircuitCode( host );
  1392. // Don't need to do this, as we're removing the circuit info anyway - djs 01/28/03
  1393. // don't clean up 0 circuit code entries
  1394. // because many hosts (neighbor sims, etc) can have the 0 circuit
  1395. if (code)
  1396. {
  1397. //if (mCircuitCodes.checkKey(code))
  1398. code_session_map_t::iterator it = mCircuitCodes.find(code);
  1399. if(it != mCircuitCodes.end())
  1400. {
  1401. LL_INFOS("Messaging") << "Circuit " << code << " removed from list" << llendl;
  1402. //mCircuitCodes.removeData(code);
  1403. mCircuitCodes.erase(it);
  1404. }
  1405. U64 ip_port = 0;
  1406. std::map<U32, U64>::iterator iter = gMessageSystem->mCircuitCodeToIPPort.find(code);
  1407. if (iter != gMessageSystem->mCircuitCodeToIPPort.end())
  1408. {
  1409. ip_port = iter->second;
  1410. gMessageSystem->mCircuitCodeToIPPort.erase(iter);
  1411. U32 old_port = (U32)(ip_port & (U64)0xFFFFFFFF);
  1412. U32 old_ip = (U32)(ip_port >> 32);
  1413. LL_INFOS("Messaging") << "Host " << LLHost(old_ip, old_port) << " circuit " << code << " removed from lookup table" << llendl;
  1414. gMessageSystem->mIPPortToCircuitCode.erase(ip_port);
  1415. }
  1416. mCircuitInfo.removeCircuitData(host);
  1417. }
  1418. else
  1419. {
  1420. // Sigh, since we can open circuits which don't have circuit
  1421. // codes, it's possible for this to happen...
  1422. LL_WARNS("Messaging") << "Couldn't find circuit code for " << host << llendl;
  1423. }
  1424. }
  1425. void LLMessageSystem::setCircuitAllowTimeout(const LLHost &host, BOOL allow)
  1426. {
  1427. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  1428. if (cdp)
  1429. {
  1430. cdp->setAllowTimeout(allow);
  1431. }
  1432. }
  1433. void LLMessageSystem::setCircuitTimeoutCallback(const LLHost &host, void (*callback_func)(const LLHost & host, void *user_data), void *user_data)
  1434. {
  1435. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  1436. if (cdp)
  1437. {
  1438. cdp->setTimeoutCallback(callback_func, user_data);
  1439. }
  1440. }
  1441. BOOL LLMessageSystem::checkCircuitBlocked(const U32 circuit)
  1442. {
  1443. LLHost host = findHost(circuit);
  1444. if (!host.isOk())
  1445. {
  1446. LL_DEBUGS("Messaging") << "checkCircuitBlocked: Unknown circuit " << circuit << llendl;
  1447. return TRUE;
  1448. }
  1449. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  1450. if (cdp)
  1451. {
  1452. return cdp->isBlocked();
  1453. }
  1454. else
  1455. {
  1456. LL_INFOS("Messaging") << "checkCircuitBlocked(circuit): Unknown host - " << host << llendl;
  1457. return FALSE;
  1458. }
  1459. }
  1460. BOOL LLMessageSystem::checkCircuitAlive(const U32 circuit)
  1461. {
  1462. LLHost host = findHost(circuit);
  1463. if (!host.isOk())
  1464. {
  1465. LL_DEBUGS("Messaging") << "checkCircuitAlive: Unknown circuit " << circuit << llendl;
  1466. return FALSE;
  1467. }
  1468. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  1469. if (cdp)
  1470. {
  1471. return cdp->isAlive();
  1472. }
  1473. else
  1474. {
  1475. LL_INFOS("Messaging") << "checkCircuitAlive(circuit): Unknown host - " << host << llendl;
  1476. return FALSE;
  1477. }
  1478. }
  1479. BOOL LLMessageSystem::checkCircuitAlive(const LLHost &host)
  1480. {
  1481. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  1482. if (cdp)
  1483. {
  1484. return cdp->isAlive();
  1485. }
  1486. else
  1487. {
  1488. LL_DEBUGS("Messaging") << "checkCircuitAlive(host): Unknown host - " << host << llendl;
  1489. return FALSE;
  1490. }
  1491. }
  1492. void LLMessageSystem::setCircuitProtection(BOOL b_protect)
  1493. {
  1494. mbProtected = b_protect;
  1495. }
  1496. U32 LLMessageSystem::findCircuitCode(const LLHost &host)
  1497. {
  1498. U64 ip64 = (U64) host.getAddress();
  1499. U64 port64 = (U64) host.getPort();
  1500. U64 ip_port = (ip64 << 32) | port64;
  1501. return get_if_there(mIPPortToCircuitCode, ip_port, U32(0));
  1502. }
  1503. LLHost LLMessageSystem::findHost(const U32 circuit_code)
  1504. {
  1505. if (mCircuitCodeToIPPort.count(circuit_code) > 0)
  1506. {
  1507. return LLHost(mCircuitCodeToIPPort[circuit_code]);
  1508. }
  1509. else
  1510. {
  1511. return LLHost::invalid;
  1512. }
  1513. }
  1514. void LLMessageSystem::setMaxMessageTime(const F32 seconds)
  1515. {
  1516. mMaxMessageTime = seconds;
  1517. }
  1518. void LLMessageSystem::setMaxMessageCounts(const S32 num)
  1519. {
  1520. mMaxMessageCounts = num;
  1521. }
  1522. std::ostream& operator<<(std::ostream& s, LLMessageSystem &msg)
  1523. {
  1524. U32 i;
  1525. if (msg.mbError)
  1526. {
  1527. s << "Message system not correctly initialized";
  1528. }
  1529. else
  1530. {
  1531. s << "Message system open on port " << msg.mPort << " and socket " << msg.mSocket << "n";
  1532. // s << "Message template file " << msg.mName << " loadedn";
  1533. s << "nHigh frequency messages:n";
  1534. for (i = 1; msg.mMessageNumbers[i] && (i < 255); i++)
  1535. {
  1536. s << *(msg.mMessageNumbers[i]);
  1537. }
  1538. s << "nMedium frequency messages:n";
  1539. for (i = (255 << 8) + 1; msg.mMessageNumbers[i] && (i < (255 << 8) + 255); i++)
  1540. {
  1541. s << *msg.mMessageNumbers[i];
  1542. }
  1543. s << "nLow frequency messages:n";
  1544. for (i = (0xFFFF0000) + 1; msg.mMessageNumbers[i] && (i < 0xFFFFFFFF); i++)
  1545. {
  1546. s << *msg.mMessageNumbers[i];
  1547. }
  1548. }
  1549. return s;
  1550. }
  1551. LLMessageSystem *gMessageSystem = NULL;
  1552. // update appropriate ping info
  1553. void process_complete_ping_check(LLMessageSystem *msgsystem, void** /*user_data*/)
  1554. {
  1555. U8 ping_id;
  1556. msgsystem->getU8Fast(_PREHASH_PingID, _PREHASH_PingID, ping_id);
  1557. LLCircuitData *cdp;
  1558. cdp = msgsystem->mCircuitInfo.findCircuit(msgsystem->getSender());
  1559. // stop the appropriate timer
  1560. if (cdp)
  1561. {
  1562. cdp->pingTimerStop(ping_id);
  1563. }
  1564. }
  1565. void process_start_ping_check(LLMessageSystem *msgsystem, void** /*user_data*/)
  1566. {
  1567. U8 ping_id;
  1568. msgsystem->getU8Fast(_PREHASH_PingID, _PREHASH_PingID, ping_id);
  1569. LLCircuitData *cdp;
  1570. cdp = msgsystem->mCircuitInfo.findCircuit(msgsystem->getSender());
  1571. if (cdp)
  1572. {
  1573. // Grab the packet id of the oldest unacked packet
  1574. U32 packet_id;
  1575. msgsystem->getU32Fast(_PREHASH_PingID, _PREHASH_OldestUnacked, packet_id);
  1576. cdp->clearDuplicateList(packet_id);
  1577. }
  1578. // Send off the response
  1579. msgsystem->newMessageFast(_PREHASH_CompletePingCheck);
  1580. msgsystem->nextBlockFast(_PREHASH_PingID);
  1581. msgsystem->addU8(_PREHASH_PingID, ping_id);
  1582. msgsystem->sendMessage(msgsystem->getSender());
  1583. }
  1584. // Note: this is currently unused. --mark
  1585. void open_circuit(LLMessageSystem *msgsystem, void** /*user_data*/)
  1586. {
  1587. U32  ip;
  1588. U16  port;
  1589. msgsystem->getIPAddrFast(_PREHASH_CircuitInfo, _PREHASH_IP, ip);
  1590. msgsystem->getIPPortFast(_PREHASH_CircuitInfo, _PREHASH_Port, port);
  1591. // By default, OpenCircuit's are untrusted
  1592. msgsystem->enableCircuit(LLHost(ip, port), FALSE);
  1593. }
  1594. void close_circuit(LLMessageSystem *msgsystem, void** /*user_data*/)
  1595. {
  1596. msgsystem->disableCircuit(msgsystem->getSender());
  1597. }
  1598. // static
  1599. /*
  1600. void LLMessageSystem::processAssignCircuitCode(LLMessageSystem* msg, void**)
  1601. {
  1602. // if we already have a circuit code, we can bail
  1603. if(msg->mOurCircuitCode) return;
  1604. LLUUID session_id;
  1605. msg->getUUIDFast(_PREHASH_CircuitCode, _PREHASH_SessionID, session_id);
  1606. if(session_id != msg->getMySessionID())
  1607. {
  1608. LL_WARNS("Messaging") << "AssignCircuitCode, bad session id. Expecting "
  1609. << msg->getMySessionID() << " but got " << session_id
  1610. << llendl;
  1611. return;
  1612. }
  1613. U32 code;
  1614. msg->getU32Fast(_PREHASH_CircuitCode, _PREHASH_Code, code);
  1615. if (!code)
  1616. {
  1617. LL_ERRS("Messaging") << "Assigning circuit code of zero!" << llendl;
  1618. }
  1619. msg->mOurCircuitCode = code;
  1620. LL_INFOS("Messaging") << "Circuit code " << code << " assigned." << llendl;
  1621. }
  1622. */
  1623. // static
  1624. void LLMessageSystem::processAddCircuitCode(LLMessageSystem* msg, void**)
  1625. {
  1626. U32 code;
  1627. msg->getU32Fast(_PREHASH_CircuitCode, _PREHASH_Code, code);
  1628. LLUUID session_id;
  1629. msg->getUUIDFast(_PREHASH_CircuitCode, _PREHASH_SessionID, session_id);
  1630. (void)msg->addCircuitCode(code, session_id);
  1631. // Send the ack back
  1632. //msg->newMessageFast(_PREHASH_AckAddCircuitCode);
  1633. //msg->nextBlockFast(_PREHASH_CircuitCode);
  1634. //msg->addU32Fast(_PREHASH_Code, code);
  1635. //msg->sendMessage(msg->getSender());
  1636. }
  1637. bool LLMessageSystem::addCircuitCode(U32 code, const LLUUID& session_id)
  1638. {
  1639. if(!code)
  1640. {
  1641. LL_WARNS("Messaging") << "addCircuitCode: zero circuit code" << llendl;
  1642. return false;
  1643. }
  1644. code_session_map_t::iterator it = mCircuitCodes.find(code);
  1645. if(it == mCircuitCodes.end())
  1646. {
  1647. LL_INFOS("Messaging") << "New circuit code " << code << " added" << llendl;
  1648. //msg->mCircuitCodes[circuit_code] = circuit_code;
  1649. mCircuitCodes.insert(code_session_map_t::value_type(code, session_id));
  1650. }
  1651. else
  1652. {
  1653. LL_INFOS("Messaging") << "Duplicate circuit code " << code << " added" << llendl;
  1654. }
  1655. return true;
  1656. }
  1657. //void ack_add_circuit_code(LLMessageSystem *msgsystem, void** /*user_data*/)
  1658. //{
  1659. // By default, we do nothing.  This particular message is only handled by the spaceserver
  1660. //}
  1661. // static
  1662. void LLMessageSystem::processUseCircuitCode(LLMessageSystem* msg,
  1663. void** user)
  1664. {
  1665. U32 circuit_code_in;
  1666. msg->getU32Fast(_PREHASH_CircuitCode, _PREHASH_Code, circuit_code_in);
  1667. U32 ip = msg->getSenderIP();
  1668. U32 port = msg->getSenderPort();
  1669. U64 ip64 = ip;
  1670. U64 port64 = port;
  1671. U64 ip_port_in = (ip64 << 32) | port64;
  1672. if (circuit_code_in)
  1673. {
  1674. //if (!msg->mCircuitCodes.checkKey(circuit_code_in))
  1675. code_session_map_t::iterator it;
  1676. it = msg->mCircuitCodes.find(circuit_code_in);
  1677. if(it == msg->mCircuitCodes.end())
  1678. {
  1679. // Whoah, abort!  We don't know anything about this circuit code.
  1680. LL_WARNS("Messaging") << "UseCircuitCode for " << circuit_code_in
  1681. << " received without AddCircuitCode message - aborting"
  1682. << llendl;
  1683. return;
  1684. }
  1685. LLUUID id;
  1686. msg->getUUIDFast(_PREHASH_CircuitCode, _PREHASH_ID, id);
  1687. LLUUID session_id;
  1688. msg->getUUIDFast(_PREHASH_CircuitCode, _PREHASH_SessionID, session_id);
  1689. if(session_id != (*it).second)
  1690. {
  1691. LL_WARNS("Messaging") << "UseCircuitCode unmatched session id. Got "
  1692. << session_id << " but expected " << (*it).second
  1693. << llendl;
  1694. return;
  1695. }
  1696. // Clean up previous references to this ip/port or circuit
  1697. U64 ip_port_old = get_if_there(msg->mCircuitCodeToIPPort, circuit_code_in, U64(0));
  1698. U32 circuit_code_old = get_if_there(msg->mIPPortToCircuitCode, ip_port_in, U32(0));
  1699. if (ip_port_old)
  1700. {
  1701. if ((ip_port_old == ip_port_in) && (circuit_code_old == circuit_code_in))
  1702. {
  1703. // Current information is the same as incoming info, ignore
  1704. LL_INFOS("Messaging") << "Got duplicate UseCircuitCode for circuit " << circuit_code_in << " to " << msg->getSender() << llendl;
  1705. return;
  1706. }
  1707. // Hmm, got a different IP and port for the same circuit code.
  1708. U32 circut_code_old_ip_port = get_if_there(msg->mIPPortToCircuitCode, ip_port_old, U32(0));
  1709. msg->mCircuitCodeToIPPort.erase(circut_code_old_ip_port);
  1710. msg->mIPPortToCircuitCode.erase(ip_port_old);
  1711. U32 old_port = (U32)(ip_port_old & (U64)0xFFFFFFFF);
  1712. U32 old_ip = (U32)(ip_port_old >> 32);
  1713. LL_INFOS("Messaging") << "Removing derelict lookup entry for circuit " << circuit_code_old << " to " << LLHost(old_ip, old_port) << llendl;
  1714. }
  1715. if (circuit_code_old)
  1716. {
  1717. LLHost cur_host(ip, port);
  1718. LL_WARNS("Messaging") << "Disabling existing circuit for " << cur_host << llendl;
  1719. msg->disableCircuit(cur_host);
  1720. if (circuit_code_old == circuit_code_in)
  1721. {
  1722. LL_WARNS("Messaging") << "Asymmetrical circuit to ip/port lookup!" << llendl;
  1723. LL_WARNS("Messaging") << "Multiple circuit codes for " << cur_host << " probably!" << llendl;
  1724. LL_WARNS("Messaging") << "Permanently disabling circuit" << llendl;
  1725. return;
  1726. }
  1727. else
  1728. {
  1729. LL_WARNS("Messaging") << "Circuit code changed for " << msg->getSender()
  1730. << " from " << circuit_code_old << " to "
  1731. << circuit_code_in << llendl;
  1732. }
  1733. }
  1734. // Since this comes from the viewer, it's untrusted, but it
  1735. // passed the circuit code and session id check, so we will go
  1736. // ahead and persist the ID associated.
  1737. LLCircuitData *cdp = msg->mCircuitInfo.findCircuit(msg->getSender());
  1738. BOOL had_circuit_already = cdp ? TRUE : FALSE;
  1739. msg->enableCircuit(msg->getSender(), FALSE);
  1740. cdp = msg->mCircuitInfo.findCircuit(msg->getSender());
  1741. if(cdp)
  1742. {
  1743. cdp->setRemoteID(id);
  1744. cdp->setRemoteSessionID(session_id);
  1745. }
  1746. if (!had_circuit_already)
  1747. {
  1748. //
  1749. // HACK HACK HACK HACK HACK!
  1750. //
  1751. // This would NORMALLY happen inside logValidMsg, but at the point that this happens
  1752. // inside logValidMsg, there's no circuit for this message yet.  So the awful thing that
  1753. // we do here is do it inside this message handler immediately AFTER the message is
  1754. // handled.
  1755. //
  1756. // We COULD not do this, but then what happens is that some of the circuit bookkeeping
  1757. // gets broken, especially the packets in count.  That causes some later packets to flush
  1758. // the RecentlyReceivedReliable list, resulting in an error in which UseCircuitCode
  1759. // doesn't get properly duplicate suppressed.  Not a BIG deal, but it's somewhat confusing
  1760. // (and bad from a state point of view).  DJS 9/23/04
  1761. //
  1762. cdp->checkPacketInID(gMessageSystem->mCurrentRecvPacketID, FALSE ); // Since this is the first message on the circuit, by definition it's not resent.
  1763. }
  1764. msg->mIPPortToCircuitCode[ip_port_in] = circuit_code_in;
  1765. msg->mCircuitCodeToIPPort[circuit_code_in] = ip_port_in;
  1766. LL_INFOS("Messaging") << "Circuit code " << circuit_code_in << " from "
  1767. << msg->getSender() << " for agent " << id << " in session "
  1768. << session_id << llendl;
  1769. const LLUseCircuitCodeResponder* responder =
  1770. (const LLUseCircuitCodeResponder*) user;
  1771. if(responder)
  1772. {
  1773. responder->complete(msg->getSender(), id);
  1774. }
  1775. }
  1776. else
  1777. {
  1778. LL_WARNS("Messaging") << "Got zero circuit code in use_circuit_code" << llendl;
  1779. }
  1780. }
  1781. // static
  1782. void LLMessageSystem::processError(LLMessageSystem* msg, void**)
  1783. {
  1784. S32 error_code = 0;
  1785. msg->getS32("Data", "Code", error_code);
  1786. std::string error_token;
  1787. msg->getString("Data", "Token", error_token);
  1788. LLUUID error_id;
  1789. msg->getUUID("Data", "ID", error_id);
  1790. std::string error_system;
  1791. msg->getString("Data", "System", error_system);
  1792. std::string error_message;
  1793. msg->getString("Data", "Message", error_message);
  1794. LL_WARNS("Messaging") << "Message error from " << msg->getSender() << " - "
  1795. << error_code << " " << error_token << " " << error_id << " ""
  1796. << error_system << "" "" << error_message << """ << llendl;
  1797. }
  1798. static LLHTTPNode& messageRootNode()
  1799. {
  1800. static LLHTTPNode root_node;
  1801. static bool initialized = false;
  1802. if (!initialized) {
  1803. initialized = true;
  1804. LLHTTPRegistrar::buildAllServices(root_node);
  1805. }
  1806. return root_node;
  1807. }
  1808. //static
  1809. void LLMessageSystem::dispatch(
  1810. const std::string& msg_name,
  1811. const LLSD& message)
  1812. {
  1813. LLPointer<LLSimpleResponse> responsep = LLSimpleResponse::create();
  1814. dispatch(msg_name, message, responsep);
  1815. }
  1816. //static
  1817. void LLMessageSystem::dispatch(
  1818. const std::string& msg_name,
  1819. const LLSD& message,
  1820. LLHTTPNode::ResponsePtr responsep)
  1821. {
  1822. if ((gMessageSystem->mMessageTemplates.find
  1823. (LLMessageStringTable::getInstance()->getString(msg_name.c_str())) ==
  1824. gMessageSystem->mMessageTemplates.end()) &&
  1825. !LLMessageConfig::isValidMessage(msg_name))
  1826. {
  1827. LL_WARNS("Messaging") << "Ignoring unknown message " << msg_name << llendl;
  1828. responsep->notFound("Invalid message name");
  1829. return;
  1830. }
  1831. std::string path = "/message/" + msg_name;
  1832. LLSD context;
  1833. const LLHTTPNode* handler = messageRootNode().traverse(path, context);
  1834. if (!handler)
  1835. {
  1836. LL_WARNS("Messaging") << "LLMessageService::dispatch > no handler for "
  1837. << path << llendl;
  1838. return;
  1839. }
  1840. // enable this for output of message names
  1841. //LL_INFOS("Messaging") << "< "" << msg_name << """ << llendl;
  1842. //lldebugs << "data: " << LLSDNotationStreamer(message) << llendl;    
  1843. handler->post(responsep, context, message);
  1844. }
  1845. //static 
  1846. void LLMessageSystem::dispatchTemplate(const std::string& msg_name,
  1847. const LLSD& message,
  1848. LLHTTPNode::ResponsePtr responsep)
  1849. {
  1850. LLTemplateMessageDispatcher dispatcher(*(gMessageSystem->mTemplateMessageReader));
  1851. dispatcher.dispatch(msg_name, message, responsep);
  1852. }
  1853. static void check_for_unrecognized_messages(
  1854. const char* type,
  1855. const LLSD& map,
  1856. LLMessageSystem::message_template_name_map_t& templates)
  1857. {
  1858. for (LLSD::map_const_iterator iter = map.beginMap(),
  1859. end = map.endMap();
  1860.  iter != end; ++iter)
  1861. {
  1862. const char* name = LLMessageStringTable::getInstance()->getString(iter->first.c_str());
  1863. if (templates.find(name) == templates.end())
  1864. {
  1865. LL_INFOS("AppInit") << "    " << type
  1866. << " ban list contains unrecognized message "
  1867. << name << LL_ENDL;
  1868. }
  1869. }
  1870. }
  1871. void LLMessageSystem::setMessageBans(
  1872. const LLSD& trusted, const LLSD& untrusted)
  1873. {
  1874. LL_DEBUGS("AppInit") << "LLMessageSystem::setMessageBans:" << LL_ENDL;
  1875. bool any_set = false;
  1876. for (message_template_name_map_t::iterator iter = mMessageTemplates.begin(),
  1877.  end = mMessageTemplates.end();
  1878.  iter != end; ++iter)
  1879. {
  1880. LLMessageTemplate* mt = iter->second;
  1881. std::string name(mt->mName);
  1882. bool ban_from_trusted
  1883. = trusted.has(name) && trusted.get(name).asBoolean();
  1884. bool ban_from_untrusted
  1885. = untrusted.has(name) && untrusted.get(name).asBoolean();
  1886. mt->mBanFromTrusted = ban_from_trusted;
  1887. mt->mBanFromUntrusted = ban_from_untrusted;
  1888. if (ban_from_trusted  ||  ban_from_untrusted)
  1889. {
  1890. LL_INFOS("AppInit") << "    " << name << " banned from "
  1891. << (ban_from_trusted ? "TRUSTED " : " ")
  1892. << (ban_from_untrusted ? "UNTRUSTED " : " ")
  1893. << LL_ENDL;
  1894. any_set = true;
  1895. }
  1896. }
  1897. if (!any_set) 
  1898. {
  1899. LL_DEBUGS("AppInit") << "    no messages banned" << LL_ENDL;
  1900. }
  1901. check_for_unrecognized_messages("trusted", trusted, mMessageTemplates);
  1902. check_for_unrecognized_messages("untrusted", untrusted, mMessageTemplates);
  1903. }
  1904. S32 LLMessageSystem::sendError(
  1905. const LLHost& host,
  1906. const LLUUID& agent_id,
  1907. S32 code,
  1908. const std::string& token,
  1909. const LLUUID& id,
  1910. const std::string& system,
  1911. const std::string& message,
  1912. const LLSD& data)
  1913. {
  1914. newMessage("Error");
  1915. nextBlockFast(_PREHASH_AgentData);
  1916. addUUIDFast(_PREHASH_AgentID, agent_id);
  1917. nextBlockFast(_PREHASH_Data);
  1918. addS32("Code", code);
  1919. addString("Token", token);
  1920. addUUID("ID", id);
  1921. addString("System", system);
  1922. std::string temp;
  1923. temp = message;
  1924. if(temp.size() > (size_t)MTUBYTES) temp.resize((size_t)MTUBYTES);
  1925. addString("Message", message);
  1926. LLPointer<LLSDBinaryFormatter> formatter = new LLSDBinaryFormatter;
  1927. std::ostringstream ostr;
  1928. formatter->format(data, ostr);
  1929. temp = ostr.str();
  1930. bool pack_data = true;
  1931. static const std::string ERROR_MESSAGE_NAME("Error");
  1932. if (LLMessageConfig::getMessageFlavor(ERROR_MESSAGE_NAME) ==
  1933. LLMessageConfig::TEMPLATE_FLAVOR)
  1934. {
  1935. S32 msg_size = temp.size() + mMessageBuilder->getMessageSize();
  1936. if(msg_size >= ETHERNET_MTU_BYTES)
  1937. {
  1938. pack_data = false;
  1939. }
  1940. }
  1941. if(pack_data)
  1942. {
  1943. addBinaryData("Data", (void*)temp.c_str(), temp.size());
  1944. }
  1945. else
  1946. {
  1947. LL_WARNS("Messaging") << "Data and message were too large -- data removed."
  1948. << llendl;
  1949. addBinaryData("Data", NULL, 0);
  1950. }
  1951. return sendReliable(host);
  1952. }
  1953. void process_packet_ack(LLMessageSystem *msgsystem, void** /*user_data*/)
  1954. {
  1955. TPACKETID packet_id;
  1956. LLHost host = msgsystem->getSender();
  1957. LLCircuitData *cdp = msgsystem->mCircuitInfo.findCircuit(host);
  1958. if (cdp)
  1959. {
  1960. S32 ack_count = msgsystem->getNumberOfBlocksFast(_PREHASH_Packets);
  1961. for (S32 i = 0; i < ack_count; i++)
  1962. {
  1963. msgsystem->getU32Fast(_PREHASH_Packets, _PREHASH_ID, packet_id, i);
  1964. // LL_DEBUGS("Messaging") << "ack recvd' from " << host << " for packet " << (TPACKETID)packet_id << llendl;
  1965. cdp->ackReliablePacket(packet_id);
  1966. }
  1967. if (!cdp->getUnackedPacketCount())
  1968. {
  1969. // Remove this circuit from the list of circuits with unacked packets
  1970. gMessageSystem->mCircuitInfo.mUnackedCircuitMap.erase(host);
  1971. }
  1972. }
  1973. }
  1974. /*
  1975. void process_log_messages(LLMessageSystem* msg, void**)
  1976. {
  1977. U8 log_message;
  1978. msg->getU8Fast(_PREHASH_Options, _PREHASH_Enable, log_message);
  1979. if (log_message)
  1980. {
  1981. LL_INFOS("Messaging") << "Starting logging via message" << llendl;
  1982. msg->startLogging();
  1983. }
  1984. else
  1985. {
  1986. LL_INFOS("Messaging") << "Stopping logging via message" << llendl;
  1987. msg->stopLogging();
  1988. }
  1989. }*/
  1990. // Make circuit trusted if the MD5 Digest matches, otherwise
  1991. // notify remote end that they are not trusted.
  1992. void process_create_trusted_circuit(LLMessageSystem *msg, void **)
  1993. {
  1994. // don't try to create trust on machines with no shared secret
  1995. std::string shared_secret = get_shared_secret();
  1996. if(shared_secret.empty()) return;
  1997. LLUUID remote_id;
  1998. msg->getUUIDFast(_PREHASH_DataBlock, _PREHASH_EndPointID, remote_id);
  1999. LLCircuitData *cdp = msg->mCircuitInfo.findCircuit(msg->getSender());
  2000. if (!cdp)
  2001. {
  2002. LL_WARNS("Messaging") << "Attempt to create trusted circuit without circuit data: "
  2003. << msg->getSender() << llendl;
  2004. return;
  2005. }
  2006. LLUUID local_id;
  2007. local_id = cdp->getLocalEndPointID();
  2008. if (remote_id == local_id)
  2009. {
  2010. // Don't respond to requests that use the same end point ID
  2011. return;
  2012. }
  2013. U32 untrusted_interface = msg->getUntrustedInterface().getAddress();
  2014. U32 last_interface = msg->getReceivingInterface().getAddress();
  2015. if ( ( untrusted_interface != INVALID_HOST_IP_ADDRESS ) && ( untrusted_interface == last_interface ) )
  2016. {
  2017. if( msg->getBlockUntrustedInterface() )
  2018. {
  2019. LL_WARNS("Messaging") << "Ignoring CreateTrustedCircuit on public interface from host: "
  2020. << msg->getSender() << llendl;
  2021. return;
  2022. }
  2023. else
  2024. {
  2025. LL_WARNS("Messaging") << "Processing CreateTrustedCircuit on public interface from host: "
  2026. << msg->getSender() << llendl;
  2027. }
  2028. }
  2029. char their_digest[MD5HEX_STR_SIZE]; /* Flawfinder: ignore */
  2030. S32 size = msg->getSizeFast(_PREHASH_DataBlock, _PREHASH_Digest);
  2031. if(size != MD5HEX_STR_BYTES)
  2032. {
  2033. // ignore requests which pack the wrong amount of data.
  2034. return;
  2035. }
  2036. msg->getBinaryDataFast(_PREHASH_DataBlock, _PREHASH_Digest, their_digest, MD5HEX_STR_BYTES);
  2037. their_digest[MD5HEX_STR_SIZE - 1] = '';
  2038. if(msg->isMatchingDigestForWindowAndUUIDs(their_digest, TRUST_TIME_WINDOW, local_id, remote_id))
  2039. {
  2040. cdp->setTrusted(TRUE);
  2041. LL_INFOS("Messaging") << "Trusted digest from " << msg->getSender() << llendl;
  2042. return;
  2043. }
  2044. else if (cdp->getTrusted())
  2045. {
  2046. // The digest is bad, but this circuit is already trusted.
  2047. // This means that this could just be the result of a stale deny sent from a while back, and
  2048. // the message system is being slow.  Don't bother sending the deny, as it may continually
  2049. // ping-pong back and forth on a very hosed circuit.
  2050. LL_WARNS("Messaging") << "Ignoring bad digest from known trusted circuit: " << their_digest
  2051. << " host: " << msg->getSender() << llendl;
  2052. return;
  2053. }
  2054. else
  2055. {
  2056. LL_WARNS("Messaging") << "Bad digest from known circuit: " << their_digest
  2057. << " host: " << msg->getSender() << llendl;
  2058. msg->sendDenyTrustedCircuit(msg->getSender());
  2059. return;
  2060. }
  2061. }    
  2062. void process_deny_trusted_circuit(LLMessageSystem *msg, void **)
  2063. {
  2064. // don't try to create trust on machines with no shared secret
  2065. std::string shared_secret = get_shared_secret();
  2066. if(shared_secret.empty()) return;
  2067. LLUUID remote_id;
  2068. msg->getUUIDFast(_PREHASH_DataBlock, _PREHASH_EndPointID, remote_id);
  2069. LLCircuitData *cdp = msg->mCircuitInfo.findCircuit(msg->getSender());
  2070. if (!cdp)
  2071. {
  2072. return;
  2073. }
  2074. LLUUID local_id;
  2075. local_id = cdp->getLocalEndPointID();
  2076. if (remote_id == local_id)
  2077. {
  2078. // Don't respond to requests that use the same end point ID
  2079. return;
  2080. }
  2081. U32 untrusted_interface = msg->getUntrustedInterface().getAddress();
  2082. U32 last_interface = msg->getReceivingInterface().getAddress();
  2083. if ( ( untrusted_interface != INVALID_HOST_IP_ADDRESS ) && ( untrusted_interface == last_interface ) )
  2084. {
  2085. if( msg->getBlockUntrustedInterface() )
  2086. {
  2087. LL_WARNS("Messaging") << "Ignoring DenyTrustedCircuit on public interface from host: "
  2088. << msg->getSender() << llendl;
  2089. return;
  2090. }
  2091. else
  2092. {
  2093. LL_WARNS("Messaging") << "Processing DenyTrustedCircuit on public interface from host: "
  2094. << msg->getSender() << llendl;
  2095. }
  2096. }
  2097. // Assume that we require trust to proceed, so resend.
  2098. // This catches the case where a circuit that was trusted
  2099. // times out, and allows us to re-establish it, but does
  2100. // mean that if our shared_secret or clock is wrong, we'll
  2101. // spin.
  2102. // *TODO: probably should keep a count of number of resends
  2103. // per circuit, and stop resending after a while.
  2104. LL_INFOS("Messaging") << "Got DenyTrustedCircuit. Sending CreateTrustedCircuit to "
  2105. << msg->getSender() << llendl;
  2106. msg->sendCreateTrustedCircuit(msg->getSender(), local_id, remote_id);
  2107. }
  2108. void dump_prehash_files()
  2109. {
  2110. U32 i;
  2111. std::string filename("../../indra/llmessage/message_prehash.h");
  2112. LLFILE* fp = LLFile::fopen(filename, "w"); /* Flawfinder: ignore */
  2113. if (fp)
  2114. {
  2115. fprintf(
  2116. fp,
  2117. "/**n"
  2118. " * @file message_prehash.hn"
  2119. " * @brief header file of externs of prehashed variables plus defines.n"
  2120. " *n"
  2121. " * $LicenseInfo:firstyear=2003&license=viewergpl$"
  2122. " * $/LicenseInfo$"
  2123. " */nn"
  2124. "#ifndef LL_MESSAGE_PREHASH_Hn#define LL_MESSAGE_PREHASH_Hnn");
  2125. fprintf(
  2126. fp,
  2127. "/**n"
  2128. " * Generated from message template version number %.3fn"
  2129. " */n",
  2130. gMessageSystem->mMessageFileVersionNumber);
  2131. fprintf(fp, "nnextern F32 gPrehashVersionNumber;nn");
  2132. for (i = 0; i < MESSAGE_NUMBER_OF_HASH_BUCKETS; i++)
  2133. {
  2134. if (!LLMessageStringTable::getInstance()->mEmpty[i] && LLMessageStringTable::getInstance()->mString[i][0] != '.')
  2135. {
  2136. fprintf(fp, "extern char * _PREHASH_%s;n", LLMessageStringTable::getInstance()->mString[i]);
  2137. }
  2138. }
  2139. fprintf(fp, "nn#endifn");
  2140. fclose(fp);
  2141. }
  2142. filename = std::string("../../indra/llmessage/message_prehash.cpp");
  2143. fp = LLFile::fopen(filename, "w"); /* Flawfinder: ignore */
  2144. if (fp)
  2145. {
  2146. fprintf(
  2147. fp,
  2148. "/**n"
  2149. " * @file message_prehash.cppn"
  2150. " * @brief file of prehashed variablesn"
  2151. " *n"
  2152. " * $LicenseInfo:firstyear=2003&license=viewergpl$"
  2153. " * $/LicenseInfo$"
  2154. " */nn"
  2155. "/**n"
  2156. " * Generated from message template version number %.3fn"
  2157. " */n",
  2158. gMessageSystem->mMessageFileVersionNumber);
  2159. fprintf(fp, "#include "linden_common.h"n");
  2160. fprintf(fp, "#include "message.h"nn");
  2161. fprintf(fp, "nnF32 gPrehashVersionNumber = %.3ff;nn", gMessageSystem->mMessageFileVersionNumber);
  2162. for (i = 0; i < MESSAGE_NUMBER_OF_HASH_BUCKETS; i++)
  2163. {
  2164. if (!LLMessageStringTable::getInstance()->mEmpty[i] && LLMessageStringTable::getInstance()->mString[i][0] != '.')
  2165. {
  2166. fprintf(fp, "char * _PREHASH_%s = LLMessageStringTable::getInstance()->getString("%s");n", LLMessageStringTable::getInstance()->mString[i], LLMessageStringTable::getInstance()->mString[i]);
  2167. }
  2168. }
  2169. fclose(fp);
  2170. }
  2171. }
  2172. bool start_messaging_system(
  2173. const std::string& template_name,
  2174. U32 port,
  2175. S32 version_major,
  2176. S32 version_minor,
  2177. S32 version_patch,
  2178. bool b_dump_prehash_file,
  2179. const std::string& secret,
  2180. const LLUseCircuitCodeResponder* responder,
  2181. bool failure_is_fatal,
  2182. const F32 circuit_heartbeat_interval, 
  2183. const F32 circuit_timeout)
  2184. {
  2185. gMessageSystem = new LLMessageSystem(
  2186. template_name,
  2187. port, 
  2188. version_major, 
  2189. version_minor, 
  2190. version_patch,
  2191. failure_is_fatal,
  2192. circuit_heartbeat_interval,
  2193. circuit_timeout);
  2194. g_shared_secret.assign(secret);
  2195. if (!gMessageSystem)
  2196. {
  2197. LL_ERRS("AppInit") << "Messaging system initialization failed." << LL_ENDL;
  2198. return FALSE;
  2199. }
  2200. // bail if system encountered an error.
  2201. if(!gMessageSystem->isOK())
  2202. {
  2203. return FALSE;
  2204. }
  2205. if (b_dump_prehash_file)
  2206. {
  2207. dump_prehash_files();
  2208. exit(0);
  2209. }
  2210. else
  2211. {
  2212. if (gMessageSystem->mMessageFileVersionNumber != gPrehashVersionNumber)
  2213. {
  2214. LL_INFOS("AppInit") << "Message template version does not match prehash version number" << LL_ENDL;
  2215. LL_INFOS("AppInit") << "Run simulator with -prehash command line option to rebuild prehash data" << llendl;
  2216. }
  2217. else
  2218. {
  2219. LL_DEBUGS("AppInit") << "Message template version matches prehash version number" << llendl;
  2220. }
  2221. }
  2222. gMessageSystem->setHandlerFuncFast(_PREHASH_StartPingCheck, process_start_ping_check, NULL);
  2223. gMessageSystem->setHandlerFuncFast(_PREHASH_CompletePingCheck, process_complete_ping_check, NULL);
  2224. gMessageSystem->setHandlerFuncFast(_PREHASH_OpenCircuit, open_circuit, NULL);
  2225. gMessageSystem->setHandlerFuncFast(_PREHASH_CloseCircuit, close_circuit, NULL);
  2226. //gMessageSystem->setHandlerFuncFast(_PREHASH_AssignCircuitCode, LLMessageSystem::processAssignCircuitCode);    
  2227. gMessageSystem->setHandlerFuncFast(_PREHASH_AddCircuitCode, LLMessageSystem::processAddCircuitCode);
  2228. //gMessageSystem->setHandlerFuncFast(_PREHASH_AckAddCircuitCode, ack_add_circuit_code, NULL);
  2229. gMessageSystem->setHandlerFuncFast(_PREHASH_UseCircuitCode, LLMessageSystem::processUseCircuitCode, (void**)responder);
  2230. gMessageSystem->setHandlerFuncFast(_PREHASH_PacketAck,             process_packet_ack,     NULL);
  2231. //gMessageSystem->setHandlerFuncFast(_PREHASH_LogMessages, process_log_messages, NULL);
  2232. gMessageSystem->setHandlerFuncFast(_PREHASH_CreateTrustedCircuit,
  2233.        process_create_trusted_circuit,
  2234.        NULL);
  2235. gMessageSystem->setHandlerFuncFast(_PREHASH_DenyTrustedCircuit,
  2236.        process_deny_trusted_circuit,
  2237.        NULL);
  2238. gMessageSystem->setHandlerFunc("Error", LLMessageSystem::processError);
  2239. // We can hand this to the null_message_callback since it is a
  2240. // trusted message, so it will automatically be denied if it isn't
  2241. // trusted and ignored if it is -- exactly what we want.
  2242. gMessageSystem->setHandlerFunc(
  2243. "RequestTrustedCircuit",
  2244. null_message_callback,
  2245. NULL);
  2246. // Initialize the transfer manager
  2247. gTransferManager.init();
  2248. return TRUE;
  2249. }
  2250. void LLMessageSystem::startLogging()
  2251. {
  2252. mVerboseLog = TRUE;
  2253. std::ostringstream str;
  2254. str << "START MESSAGE LOG" << std::endl;
  2255. str << "Legend:" << std::endl;
  2256. str << "t<-tincoming message" <<std::endl;
  2257. str << "t->toutgoing message" << std::endl;
  2258. str << "     <>        host           size    zero      id name";
  2259. LL_INFOS("Messaging") << str.str() << llendl;
  2260. }
  2261. void LLMessageSystem::stopLogging()
  2262. {
  2263. if(mVerboseLog)
  2264. {
  2265. mVerboseLog = FALSE;
  2266. LL_INFOS("Messaging") << "END MESSAGE LOG" << llendl;
  2267. }
  2268. }
  2269. void LLMessageSystem::summarizeLogs(std::ostream& str)
  2270. {
  2271.   std::string buffer;
  2272. std::string tmp_str;
  2273. F32 run_time = mMessageSystemTimer.getElapsedTimeF32();
  2274. str << "START MESSAGE LOG SUMMARY" << std::endl;
  2275. buffer = llformat( "Run time: %12.3f seconds", run_time);
  2276. // Incoming
  2277. str << buffer << std::endl << "Incoming:" << std::endl;
  2278. tmp_str = U64_to_str(mTotalBytesIn);
  2279. buffer = llformat( "Total bytes received:      %20s (%5.2f kbits per second)", tmp_str.c_str(), ((F32)mTotalBytesIn * 0.008f) / run_time);
  2280. str << buffer << std::endl;
  2281. tmp_str = U64_to_str(mPacketsIn);
  2282. buffer = llformat( "Total packets received:    %20s (%5.2f packets per second)", tmp_str.c_str(), ((F32) mPacketsIn / run_time));
  2283. str << buffer << std::endl;
  2284. buffer = llformat( "Average packet size:       %20.0f bytes", (F32)mTotalBytesIn / (F32)mPacketsIn);
  2285. str << buffer << std::endl;
  2286. tmp_str = U64_to_str(mReliablePacketsIn);
  2287. buffer = llformat( "Total reliable packets:    %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mReliablePacketsIn)/((F32) mPacketsIn + 1));
  2288. str << buffer << std::endl;
  2289. tmp_str = U64_to_str(mCompressedPacketsIn);
  2290. buffer = llformat( "Total compressed packets:  %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mCompressedPacketsIn)/((F32) mPacketsIn + 1));
  2291. str << buffer << std::endl;
  2292. S64 savings = mUncompressedBytesIn - mCompressedBytesIn;
  2293. tmp_str = U64_to_str(savings);
  2294. buffer = llformat( "Total compression savings: %20s bytes", tmp_str.c_str());
  2295. str << buffer << std::endl;
  2296. tmp_str = U64_to_str(savings/(mCompressedPacketsIn +1));
  2297. buffer = llformat( "Avg comp packet savings:   %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mUncompressedBytesIn)/((F32) mCompressedBytesIn+1));
  2298. str << buffer << std::endl;
  2299. tmp_str = U64_to_str(savings/(mPacketsIn+1));
  2300. buffer = llformat( "Avg overall comp savings:  %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mTotalBytesIn + (F32) savings)/((F32) mTotalBytesIn + 1.f));
  2301. // Outgoing
  2302. str << buffer << std::endl << std::endl << "Outgoing:" << std::endl;
  2303. tmp_str = U64_to_str(mTotalBytesOut);
  2304. buffer = llformat( "Total bytes sent:          %20s (%5.2f kbits per second)", tmp_str.c_str(), ((F32)mTotalBytesOut * 0.008f) / run_time );
  2305. str << buffer << std::endl;
  2306. tmp_str = U64_to_str(mPacketsOut);
  2307. buffer = llformat( "Total packets sent:        %20s (%5.2f packets per second)", tmp_str.c_str(), ((F32)mPacketsOut / run_time));
  2308. str << buffer << std::endl;
  2309. buffer = llformat( "Average packet size:       %20.0f bytes", (F32)mTotalBytesOut / (F32)mPacketsOut);
  2310. str << buffer << std::endl;
  2311. tmp_str = U64_to_str(mReliablePacketsOut);
  2312. buffer = llformat( "Total reliable packets:    %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mReliablePacketsOut)/((F32) mPacketsOut + 1));
  2313. str << buffer << std::endl;
  2314. tmp_str = U64_to_str(mCompressedPacketsOut);
  2315. buffer = llformat( "Total compressed packets:  %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mCompressedPacketsOut)/((F32) mPacketsOut + 1));
  2316. str << buffer << std::endl;
  2317. savings = mUncompressedBytesOut - mCompressedBytesOut;
  2318. tmp_str = U64_to_str(savings);
  2319. buffer = llformat( "Total compression savings: %20s bytes", tmp_str.c_str());
  2320. str << buffer << std::endl;
  2321. tmp_str = U64_to_str(savings/(mCompressedPacketsOut +1));
  2322. buffer = llformat( "Avg comp packet savings:   %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mUncompressedBytesOut)/((F32) mCompressedBytesOut+1));
  2323. str << buffer << std::endl;
  2324. tmp_str = U64_to_str(savings/(mPacketsOut+1));
  2325. buffer = llformat( "Avg overall comp savings:  %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mTotalBytesOut + (F32) savings)/((F32) mTotalBytesOut + 1.f));
  2326. str << buffer << std::endl << std::endl;
  2327. buffer = llformat( "SendPacket failures:       %20d", mSendPacketFailureCount);
  2328. str << buffer << std::endl;
  2329. buffer = llformat( "Dropped packets:           %20d", mDroppedPackets);
  2330. str << buffer << std::endl;
  2331. buffer = llformat( "Resent packets:            %20d", mResentPackets);
  2332. str << buffer << std::endl;
  2333. buffer = llformat( "Failed reliable resends:   %20d", mFailedResendPackets);
  2334. str << buffer << std::endl;
  2335. buffer = llformat( "Off-circuit rejected packets: %17d", mOffCircuitPackets);
  2336. str << buffer << std::endl;
  2337. buffer = llformat( "On-circuit invalid packets:   %17d", mInvalidOnCircuitPackets);
  2338. str << buffer << std::endl << std::endl;
  2339. str << "Decoding: " << std::endl;
  2340. buffer = llformat( "%35s%10s%10s%10s%10s", "Message", "Count", "Time", "Max", "Avg");
  2341. str << buffer << std:: endl;
  2342. F32 avg;
  2343. for (message_template_name_map_t::const_iterator iter = mMessageTemplates.begin(),
  2344.  end = mMessageTemplates.end();
  2345.  iter != end; iter++)
  2346. {
  2347. const LLMessageTemplate* mt = iter->second;
  2348. if(mt->mTotalDecoded > 0)
  2349. {
  2350. avg = mt->mTotalDecodeTime / (F32)mt->mTotalDecoded;
  2351. buffer = llformat( "%35s%10u%10f%10f%10f", mt->mName, mt->mTotalDecoded, mt->mTotalDecodeTime, mt->mMaxDecodeTimePerMsg, avg);
  2352. str << buffer << std::endl;
  2353. }
  2354. }
  2355. str << "END MESSAGE LOG SUMMARY" << std::endl;
  2356. }
  2357. void end_messaging_system(bool print_summary)
  2358. {
  2359. gTransferManager.cleanup();
  2360. LLTransferTargetVFile::updateQueue(true); // shutdown LLTransferTargetVFile
  2361. if (gMessageSystem)
  2362. {
  2363. gMessageSystem->stopLogging();
  2364. if (print_summary)
  2365. {
  2366. std::ostringstream str;
  2367. gMessageSystem->summarizeLogs(str);
  2368. LL_INFOS("Messaging") << str.str().c_str() << llendl;
  2369. }
  2370. delete gMessageSystem;
  2371. gMessageSystem = NULL;
  2372. }
  2373. }
  2374. void LLMessageSystem::resetReceiveCounts()
  2375. {
  2376. mNumMessageCounts = 0;
  2377. for (message_template_name_map_t::iterator iter = mMessageTemplates.begin(),
  2378.  end = mMessageTemplates.end();
  2379.  iter != end; iter++)
  2380. {
  2381. LLMessageTemplate* mt = iter->second;
  2382. mt->mDecodeTimeThisFrame = 0.f;
  2383. }
  2384. }
  2385. void LLMessageSystem::dumpReceiveCounts()
  2386. {
  2387. LLMessageTemplate *mt;
  2388. for (message_template_name_map_t::iterator iter = mMessageTemplates.begin(),
  2389.  end = mMessageTemplates.end();
  2390.  iter != end; iter++)
  2391. {
  2392. LLMessageTemplate* mt = iter->second;
  2393. mt->mReceiveCount = 0;
  2394. mt->mReceiveBytes = 0;
  2395. mt->mReceiveInvalid = 0;
  2396. }
  2397. S32 i;
  2398. for (i = 0; i < mNumMessageCounts; i++)
  2399. {
  2400. mt = get_ptr_in_map(mMessageNumbers,mMessageCountList[i].mMessageNum);
  2401. if (mt)
  2402. {
  2403. mt->mReceiveCount++;
  2404. mt->mReceiveBytes += mMessageCountList[i].mMessageBytes;
  2405. if (mMessageCountList[i].mInvalid)
  2406. {
  2407. mt->mReceiveInvalid++;
  2408. }
  2409. }
  2410. }
  2411. if(mNumMessageCounts > 0)
  2412. {
  2413. LL_DEBUGS("Messaging") << "Dump: " << mNumMessageCounts << " messages processed in " << mReceiveTime << " seconds" << llendl;
  2414. for (message_template_name_map_t::const_iterator iter = mMessageTemplates.begin(),
  2415.  end = mMessageTemplates.end();
  2416.  iter != end; iter++)
  2417. {
  2418. const LLMessageTemplate* mt = iter->second;
  2419. if (mt->mReceiveCount > 0)
  2420. {
  2421. LL_INFOS("Messaging") << "Num: " << std::setw(3) << mt->mReceiveCount << " Bytes: " << std::setw(6) << mt->mReceiveBytes
  2422. << " Invalid: " << std::setw(3) << mt->mReceiveInvalid << " " << mt->mName << " " << llround(100 * mt->mDecodeTimeThisFrame / mReceiveTime) << "%" << llendl;
  2423. }
  2424. }
  2425. }
  2426. }
  2427. BOOL LLMessageSystem::isClear() const
  2428. {
  2429. return mMessageBuilder->isClear();
  2430. }
  2431. S32 LLMessageSystem::flush(const LLHost &host)
  2432. {
  2433. if (mMessageBuilder->getMessageSize())
  2434. {
  2435. S32 sentbytes = sendMessage(host);
  2436. clearMessage();
  2437. return sentbytes;
  2438. }
  2439. else
  2440. {
  2441. return 0;
  2442. }
  2443. }
  2444. U32 LLMessageSystem::getListenPort( void ) const
  2445. {
  2446. return mPort;
  2447. }
  2448. // TODO: babbage: remove this horror!
  2449. S32 LLMessageSystem::zeroCodeAdjustCurrentSendTotal()
  2450. {
  2451. if(mMessageBuilder == mLLSDMessageBuilder)
  2452. {
  2453. // babbage: don't compress LLSD messages, so delta is 0
  2454. return 0;
  2455. }
  2456. if (! mMessageBuilder->isBuilt())
  2457. {
  2458. mSendSize = mMessageBuilder->buildMessage(
  2459. mSendBuffer,
  2460. MAX_BUFFER_SIZE,
  2461. 0);
  2462. }
  2463. // TODO: babbage: remove this horror
  2464. mMessageBuilder->setBuilt(FALSE);
  2465. S32 count = mSendSize;
  2466. S32 net_gain = 0;
  2467. U8 num_zeroes = 0;
  2468. U8 *inptr = (U8 *)mSendBuffer;
  2469. // skip the packet id field
  2470. for (U32 ii = 0; ii < LL_PACKET_ID_SIZE; ++ii)
  2471. {
  2472. count--;
  2473. inptr++;
  2474. }
  2475. // don't actually build, just test
  2476. // sequential zero bytes are encoded as 0 [U8 count] 
  2477. // with 0 0 [count] representing wrap (>256 zeroes)
  2478. while (count--)
  2479. {
  2480. if (!(*inptr))   // in a zero count
  2481. {
  2482. if (num_zeroes)
  2483. {
  2484. if (++num_zeroes > 254)
  2485. {
  2486. num_zeroes = 0;
  2487. }
  2488. net_gain--;   // subseqent zeroes save one
  2489. }
  2490. else
  2491. {
  2492. net_gain++;  // starting a zero count adds one
  2493. num_zeroes = 1;
  2494. }
  2495. inptr++;
  2496. }
  2497. else
  2498. {
  2499. if (num_zeroes)
  2500. {
  2501. num_zeroes = 0;
  2502. }
  2503. inptr++;
  2504. }
  2505. }
  2506. if (net_gain < 0)
  2507. {
  2508. return net_gain;
  2509. }
  2510. else
  2511. {
  2512. return 0;
  2513. }
  2514. }
  2515. S32 LLMessageSystem::zeroCodeExpand(U8** data, S32* data_size)
  2516. {
  2517. if ((*data_size ) < LL_MINIMUM_VALID_PACKET_SIZE)
  2518. {
  2519. LL_WARNS("Messaging") << "zeroCodeExpand() called with data_size of " << *data_size
  2520. << llendl;
  2521. }
  2522. mTotalBytesIn += *data_size;
  2523. // if we're not zero-coded, simply return.
  2524. if (!(*data[0] & LL_ZERO_CODE_FLAG))
  2525. {
  2526. return 0;
  2527. }
  2528. S32 in_size = *data_size;
  2529. mCompressedPacketsIn++;
  2530. mCompressedBytesIn += *data_size;
  2531. *data[0] &= (~LL_ZERO_CODE_FLAG);
  2532. S32 count = (*data_size);  
  2533. U8 *inptr = (U8 *)*data;
  2534. U8 *outptr = (U8 *)mEncodedRecvBuffer;
  2535. // skip the packet id field
  2536. for (U32 ii = 0; ii < LL_PACKET_ID_SIZE; ++ii)
  2537. {
  2538. count--;
  2539. *outptr++ = *inptr++;
  2540. }
  2541. // reconstruct encoded packet, keeping track of net size gain
  2542. // sequential zero bytes are encoded as 0 [U8 count] 
  2543. // with 0 0 [count] representing wrap (>256 zeroes)
  2544. while (count--)
  2545. {
  2546. if (outptr > (&mEncodedRecvBuffer[MAX_BUFFER_SIZE-1]))
  2547. {
  2548. LL_WARNS("Messaging") << "attempt to write past reasonable encoded buffer size 1" << llendl;
  2549. callExceptionFunc(MX_WROTE_PAST_BUFFER_SIZE);
  2550. outptr = mEncodedRecvBuffer;
  2551. break;
  2552. }
  2553. if (!((*outptr++ = *inptr++)))
  2554. {
  2555. while (((count--)) && (!(*inptr)))
  2556. {
  2557. *outptr++ = *inptr++;
  2558.    if (outptr > (&mEncodedRecvBuffer[MAX_BUFFER_SIZE-256]))
  2559.    {
  2560.    LL_WARNS("Messaging") << "attempt to write past reasonable encoded buffer size 2" << llendl;
  2561. callExceptionFunc(MX_WROTE_PAST_BUFFER_SIZE);
  2562. outptr = mEncodedRecvBuffer;
  2563. count = -1;
  2564. break;
  2565.    }
  2566. memset(outptr,0,255);
  2567. outptr += 255;
  2568. }
  2569. if (count < 0)
  2570. {
  2571. break;
  2572. }
  2573. else
  2574. {
  2575.    if (outptr > (&mEncodedRecvBuffer[MAX_BUFFER_SIZE-(*inptr)]))
  2576. {
  2577.    LL_WARNS("Messaging") << "attempt to write past reasonable encoded buffer size 3" << llendl;
  2578. callExceptionFunc(MX_WROTE_PAST_BUFFER_SIZE);
  2579. outptr = mEncodedRecvBuffer;
  2580. }
  2581. memset(outptr,0,(*inptr) - 1);
  2582. outptr += ((*inptr) - 1);
  2583. inptr++;
  2584. }
  2585. }
  2586. }
  2587. *data = mEncodedRecvBuffer;
  2588. *data_size = (S32)(outptr - mEncodedRecvBuffer);
  2589. mUncompressedBytesIn += *data_size;
  2590. return(in_size);
  2591. }
  2592. void LLMessageSystem::addTemplate(LLMessageTemplate *templatep)
  2593. {
  2594. if (mMessageTemplates.count(templatep->mName) > 0)
  2595. {
  2596. LL_ERRS("Messaging") << templatep->mName << " already  used as a template name!"
  2597. << llendl;
  2598. }
  2599. mMessageTemplates[templatep->mName] = templatep;
  2600. mMessageNumbers[templatep->mMessageNumber] = templatep;
  2601. }
  2602. void LLMessageSystem::setHandlerFuncFast(const char *name, void (*handler_func)(LLMessageSystem *msgsystem, void **user_data), void **user_data)
  2603. {
  2604. LLMessageTemplate* msgtemplate = get_ptr_in_map(mMessageTemplates, name);
  2605. if (msgtemplate)
  2606. {
  2607. msgtemplate->setHandlerFunc(handler_func, user_data);
  2608. }
  2609. else
  2610. {
  2611. LL_ERRS("Messaging") << name << " is not a known message name!" << llendl;
  2612. }
  2613. }
  2614. bool LLMessageSystem::callHandler(const char *name,
  2615. bool trustedSource, LLMessageSystem* msg)
  2616. {
  2617. name = LLMessageStringTable::getInstance()->getString(name);
  2618. message_template_name_map_t::const_iterator iter;
  2619. iter = mMessageTemplates.find(name);
  2620. if(iter == mMessageTemplates.end())
  2621. {
  2622. LL_WARNS("Messaging") << "LLMessageSystem::callHandler: unknown message " 
  2623. << name << llendl;
  2624. return false;
  2625. }
  2626. const LLMessageTemplate* msg_template = iter->second;
  2627. if (msg_template->isBanned(trustedSource))
  2628. {
  2629. LL_WARNS("Messaging") << "LLMessageSystem::callHandler: banned message " 
  2630. << name 
  2631. << " from "
  2632. << (trustedSource ? "trusted " : "untrusted ")
  2633. << "source" << llendl;
  2634. return false;
  2635. }
  2636. return msg_template->callHandlerFunc(msg);
  2637. }
  2638. void LLMessageSystem::setExceptionFunc(EMessageException e,
  2639.    msg_exception_callback func,
  2640.    void* data)
  2641. {
  2642. callbacks_t::iterator it = mExceptionCallbacks.find(e);
  2643. if(it != mExceptionCallbacks.end())
  2644. {
  2645. mExceptionCallbacks.erase(it);
  2646. }
  2647. if(func)
  2648. {
  2649. mExceptionCallbacks.insert(callbacks_t::value_type(e, exception_t(func, data)));
  2650. }
  2651. }
  2652. BOOL LLMessageSystem::callExceptionFunc(EMessageException exception)
  2653. {
  2654. callbacks_t::iterator it = mExceptionCallbacks.find(exception);
  2655. if(it != mExceptionCallbacks.end())
  2656. {
  2657. ((*it).second.first)(this, (*it).second.second,exception);
  2658. return TRUE;
  2659. }
  2660. return FALSE;
  2661. }
  2662. void LLMessageSystem::setTimingFunc(msg_timing_callback func, void* data)
  2663. {
  2664. mTimingCallback = func;
  2665. mTimingCallbackData = data;
  2666. }
  2667. BOOL LLMessageSystem::isCircuitCodeKnown(U32 code) const
  2668. {
  2669. if(mCircuitCodes.find(code) == mCircuitCodes.end())
  2670. return FALSE;
  2671. return TRUE;
  2672. }
  2673. BOOL LLMessageSystem::isMessageFast(const char *msg)
  2674. {
  2675. return msg == mMessageReader->getMessageName();
  2676. }
  2677. char* LLMessageSystem::getMessageName()
  2678. {
  2679. return const_cast<char*>(mMessageReader->getMessageName());
  2680. }
  2681. const LLUUID& LLMessageSystem::getSenderID() const
  2682. {
  2683. LLCircuitData *cdp = mCircuitInfo.findCircuit(mLastSender);
  2684. if (cdp)
  2685. {
  2686. return (cdp->mRemoteID);
  2687. }
  2688. return LLUUID::null;
  2689. }
  2690. const LLUUID& LLMessageSystem::getSenderSessionID() const
  2691. {
  2692. LLCircuitData *cdp = mCircuitInfo.findCircuit(mLastSender);
  2693. if (cdp)
  2694. {
  2695. return (cdp->mRemoteSessionID);
  2696. }
  2697. return LLUUID::null;
  2698. }
  2699. bool LLMessageSystem::generateDigestForNumberAndUUIDs(
  2700. char* digest,
  2701. const U32 number,
  2702. const LLUUID& id1,
  2703. const LLUUID& id2) const
  2704. {
  2705. // *NOTE: This method is needlessly inefficient. Instead of
  2706. // calling LLUUID::asString, it should just call
  2707. // LLUUID::toString().
  2708. const char *colon = ":";
  2709. char tbuf[16]; /* Flawfinder: ignore */ 
  2710. LLMD5 d;
  2711. std::string id1string = id1.asString();
  2712. std::string id2string = id2.asString();
  2713. std::string shared_secret = get_shared_secret();
  2714. unsigned char * secret = (unsigned char*)shared_secret.c_str();
  2715. unsigned char * id1str = (unsigned char*)id1string.c_str();
  2716. unsigned char * id2str = (unsigned char*)id2string.c_str();
  2717. memset(digest, 0, MD5HEX_STR_SIZE);
  2718. if( secret != NULL)
  2719. {
  2720. d.update(secret, (U32)strlen((char *) secret)); /* Flawfinder: ignore */
  2721. }
  2722. d.update((const unsigned char *) colon, (U32)strlen(colon)); /* Flawfinder: ignore */ 
  2723. snprintf(tbuf, sizeof(tbuf),"%i", number); /* Flawfinder: ignore */
  2724. d.update((unsigned char *) tbuf, (U32)strlen(tbuf)); /* Flawfinder: ignore */ 
  2725. d.update((const unsigned char *) colon, (U32)strlen(colon)); /* Flawfinder: ignore */ 
  2726. if( (char*) id1str != NULL)
  2727. {
  2728. d.update(id1str, (U32)strlen((char *) id1str)); /* Flawfinder: ignore */  
  2729. }
  2730. d.update((const unsigned char *) colon, (U32)strlen(colon)); /* Flawfinder: ignore */ 
  2731. if( (char*) id2str != NULL)
  2732. {
  2733. d.update(id2str, (U32)strlen((char *) id2str)); /* Flawfinder: ignore */
  2734. }
  2735. d.finalize();
  2736. d.hex_digest(digest);
  2737. digest[MD5HEX_STR_SIZE - 1] = '';
  2738. return true;
  2739. }
  2740. bool LLMessageSystem::generateDigestForWindowAndUUIDs(char* digest, const S32 window, const LLUUID &id1, const LLUUID &id2) const
  2741. {
  2742. if(0 == window) return false;
  2743. std::string shared_secret = get_shared_secret();
  2744. if(shared_secret.empty())
  2745. {
  2746. LL_ERRS("Messaging") << "Trying to generate complex digest on a machine without a shared secret!" << llendl;
  2747. }
  2748. U32 now = time(NULL);
  2749. now /= window;
  2750. bool result = generateDigestForNumberAndUUIDs(digest, now, id1, id2);
  2751. return result;
  2752. }
  2753. bool LLMessageSystem::isMatchingDigestForWindowAndUUIDs(const char* digest, const S32 window, const LLUUID &id1, const LLUUID &id2) const
  2754. {
  2755. if(0 == window) return false;
  2756. std::string shared_secret = get_shared_secret();
  2757. if(shared_secret.empty())
  2758. {
  2759. LL_ERRS("Messaging") << "Trying to compare complex digests on a machine without a shared secret!" << llendl;
  2760. }
  2761. char our_digest[MD5HEX_STR_SIZE]; /* Flawfinder: ignore */
  2762. U32 now = time(NULL);
  2763. now /= window;
  2764. // Check 1 window ago, now, and one window from now to catch edge
  2765. // conditions. Process them as current window, one window ago, and
  2766. // one window in the future to catch the edges.
  2767. const S32 WINDOW_BIN_COUNT = 3;
  2768. U32 window_bin[WINDOW_BIN_COUNT];
  2769. window_bin[0] = now;
  2770. window_bin[1] = now - 1;
  2771. window_bin[2] = now + 1;
  2772. for(S32 i = 0; i < WINDOW_BIN_COUNT; ++i)
  2773. {
  2774. generateDigestForNumberAndUUIDs(our_digest, window_bin[i], id2, id1);
  2775. if(0 == strncmp(digest, our_digest, MD5HEX_STR_BYTES))
  2776. {
  2777. return true;
  2778. }
  2779. }
  2780. return false;
  2781. }
  2782. bool LLMessageSystem::generateDigestForNumber(char* digest, const U32 number) const
  2783. {
  2784. memset(digest, 0, MD5HEX_STR_SIZE);
  2785. LLMD5 d;
  2786. std::string shared_secret = get_shared_secret();
  2787. d = LLMD5((const unsigned char *)shared_secret.c_str(), number);
  2788. d.hex_digest(digest);
  2789. digest[MD5HEX_STR_SIZE - 1] = '';
  2790. return true;
  2791. }
  2792. bool LLMessageSystem::generateDigestForWindow(char* digest, const S32 window) const
  2793. {
  2794. if(0 == window) return false;
  2795. std::string shared_secret = get_shared_secret();
  2796. if(shared_secret.empty())
  2797. {
  2798. LL_ERRS("Messaging") << "Trying to generate simple digest on a machine without a shared secret!" << llendl;
  2799. }
  2800. U32 now = time(NULL);
  2801. now /= window;
  2802. bool result = generateDigestForNumber(digest, now);
  2803. return result;
  2804. }
  2805. bool LLMessageSystem::isMatchingDigestForWindow(const char* digest, S32 const window) const
  2806. {
  2807. if(0 == window) return false;
  2808. std::string shared_secret = get_shared_secret();
  2809. if(shared_secret.empty())
  2810. {
  2811. LL_ERRS("Messaging") << "Trying to compare simple digests on a machine without a shared secret!" << llendl;
  2812. }
  2813. char our_digest[MD5HEX_STR_SIZE]; /* Flawfinder: ignore */
  2814. U32 now = (S32)time(NULL);
  2815. now /= window;
  2816. // Check 1 window ago, now, and one window from now to catch edge
  2817. // conditions. Process them as current window, one window ago, and
  2818. // one window in the future to catch the edges.
  2819. const S32 WINDOW_BIN_COUNT = 3;
  2820. U32 window_bin[WINDOW_BIN_COUNT];
  2821. window_bin[0] = now;
  2822. window_bin[1] = now - 1;
  2823. window_bin[2] = now + 1;
  2824. for(S32 i = 0; i < WINDOW_BIN_COUNT; ++i)
  2825. {
  2826. generateDigestForNumber(our_digest, window_bin[i]);
  2827. if(0 == strncmp(digest, our_digest, MD5HEX_STR_BYTES))
  2828. {
  2829. return true;
  2830. }
  2831. }
  2832. return false;
  2833. }
  2834. void LLMessageSystem::sendCreateTrustedCircuit(const LLHost &host, const LLUUID & id1, const LLUUID & id2)
  2835. {
  2836. std::string shared_secret = get_shared_secret();
  2837. if(shared_secret.empty()) return;
  2838. char digest[MD5HEX_STR_SIZE]; /* Flawfinder: ignore */
  2839. if (id1.isNull())
  2840. {
  2841. LL_WARNS("Messaging") << "Can't send CreateTrustedCircuit to " << host << " because we don't have the local end point ID" << llendl;
  2842. return;
  2843. }
  2844. if (id2.isNull())
  2845. {
  2846. LL_WARNS("Messaging") << "Can't send CreateTrustedCircuit to " << host << " because we don't have the remote end point ID" << llendl;
  2847. return;
  2848. }
  2849. generateDigestForWindowAndUUIDs(digest, TRUST_TIME_WINDOW, id1, id2);
  2850. newMessageFast(_PREHASH_CreateTrustedCircuit);
  2851. nextBlockFast(_PREHASH_DataBlock);
  2852. addUUIDFast(_PREHASH_EndPointID, id1);
  2853. addBinaryDataFast(_PREHASH_Digest, digest, MD5HEX_STR_BYTES);
  2854. LL_INFOS("Messaging") << "xmitting digest: " << digest << " Host: " << host << llendl;
  2855. sendMessage(host);
  2856. }
  2857. void LLMessageSystem::sendDenyTrustedCircuit(const LLHost &host)
  2858. {
  2859. mDenyTrustedCircuitSet.insert(host);
  2860. }
  2861. void LLMessageSystem::reallySendDenyTrustedCircuit(const LLHost &host)
  2862. {
  2863. LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
  2864. if (!cdp)
  2865. {
  2866. LL_WARNS("Messaging") << "Not sending DenyTrustedCircuit to host without a circuit." << llendl;
  2867. return;
  2868. }
  2869. LL_INFOS("Messaging") << "Sending DenyTrustedCircuit to " << host << llendl;
  2870. newMessageFast(_PREHASH_DenyTrustedCircuit);
  2871. nextBlockFast(_PREHASH_DataBlock);
  2872. addUUIDFast(_PREHASH_EndPointID, cdp->getLocalEndPointID());
  2873. sendMessage(host);
  2874. }
  2875. void null_message_callback(LLMessageSystem *msg, void **data)
  2876. {
  2877. // Nothing should ever go here, but we use this to register messages
  2878. // that we are expecting to see (and spinning on) at startup.
  2879. return;
  2880. }
  2881. // Try to establish a bidirectional trust metric by pinging a host until it's
  2882. // up, and then sending auth messages.
  2883. void LLMessageSystem::establishBidirectionalTrust(const LLHost &host, S64 frame_count )
  2884. {
  2885. std::string shared_secret = get_shared_secret();
  2886. if(shared_secret.empty())
  2887. {
  2888. LL_ERRS("Messaging") << "Trying to establish bidirectional trust on a machine without a shared secret!" << llendl;
  2889. }
  2890. LLTimer timeout;
  2891. timeout.setTimerExpirySec(20.0);
  2892. setHandlerFuncFast(_PREHASH_StartPingCheck, null_message_callback, NULL);
  2893. setHandlerFuncFast(_PREHASH_CompletePingCheck, null_message_callback,
  2894.        NULL);
  2895. while (! timeout.hasExpired())
  2896. {
  2897. newMessageFast(_PREHASH_StartPingCheck);
  2898. nextBlockFast(_PREHASH_PingID);
  2899. addU8Fast(_PREHASH_PingID, 0);
  2900. addU32Fast(_PREHASH_OldestUnacked, 0);
  2901. sendMessage(host);
  2902. if (checkMessages( frame_count ))
  2903. {
  2904. if (isMessageFast(_PREHASH_CompletePingCheck) &&
  2905.     (getSender() == host))
  2906. {
  2907. break;
  2908. }
  2909. }
  2910. processAcks();
  2911. ms_sleep(1);
  2912. }
  2913. // Send a request, a deny, and give the host 2 seconds to complete
  2914. // the trust handshake.
  2915. newMessage("RequestTrustedCircuit");
  2916. sendMessage(host);
  2917. reallySendDenyTrustedCircuit(host);
  2918. setHandlerFuncFast(_PREHASH_StartPingCheck, process_start_ping_check, NULL);
  2919. setHandlerFuncFast(_PREHASH_CompletePingCheck, process_complete_ping_check, NULL);
  2920. timeout.setTimerExpirySec(2.0);
  2921. LLCircuitData* cdp = NULL;
  2922. while(!timeout.hasExpired())
  2923. {
  2924. cdp = mCircuitInfo.findCircuit(host);
  2925. if(!cdp) break; // no circuit anymore, no point continuing.
  2926. if(cdp->getTrusted()) break; // circuit is trusted.
  2927. checkMessages(frame_count);
  2928. processAcks();
  2929. ms_sleep(1);
  2930. }
  2931. }
  2932. void LLMessageSystem::dumpPacketToLog()
  2933. {
  2934. LL_WARNS("Messaging") << "Packet Dump from:" << mPacketRing.getLastSender() << llendl;
  2935. LL_WARNS("Messaging") << "Packet Size:" << mTrueReceiveSize << llendl;
  2936. char line_buffer[256]; /* Flawfinder: ignore */
  2937. S32 i;
  2938. S32 cur_line_pos = 0;
  2939. S32 cur_line = 0;
  2940. for (i = 0; i < mTrueReceiveSize; i++)
  2941. {
  2942. S32 offset = cur_line_pos * 3;
  2943. snprintf(line_buffer + offset, sizeof(line_buffer) - offset,
  2944.  "%02x ", mTrueReceiveBuffer[i]); /* Flawfinder: ignore */
  2945. cur_line_pos++;
  2946. if (cur_line_pos >= 16)
  2947. {
  2948. cur_line_pos = 0;
  2949. LL_WARNS("Messaging") << "PD:" << cur_line << "PD:" << line_buffer << llendl;
  2950. cur_line++;
  2951. }
  2952. }
  2953. if (cur_line_pos)
  2954. {
  2955. LL_WARNS("Messaging") << "PD:" << cur_line << "PD:" << line_buffer << llendl;
  2956. }
  2957. }
  2958. //static
  2959. U64 LLMessageSystem::getMessageTimeUsecs(const BOOL update)
  2960. {
  2961. if (gMessageSystem)
  2962. {
  2963. if (update)
  2964. {
  2965. gMessageSystem->mCurrentMessageTimeSeconds = totalTime()*SEC_PER_USEC;
  2966. }
  2967. return (U64)(gMessageSystem->mCurrentMessageTimeSeconds * USEC_PER_SEC);
  2968. }
  2969. else
  2970. {
  2971. return totalTime();
  2972. }
  2973. }
  2974. //static
  2975. F64 LLMessageSystem::getMessageTimeSeconds(const BOOL update)
  2976. {
  2977. if (gMessageSystem)
  2978. {
  2979. if (update)
  2980. {
  2981. gMessageSystem->mCurrentMessageTimeSeconds = totalTime()*SEC_PER_USEC;
  2982. }
  2983. return gMessageSystem->mCurrentMessageTimeSeconds;
  2984. }
  2985. else
  2986. {
  2987. return totalTime()*SEC_PER_USEC;
  2988. }
  2989. }
  2990. std::string get_shared_secret()
  2991. {
  2992. static const std::string SHARED_SECRET_KEY("shared_secret");
  2993. if(g_shared_secret.empty())
  2994. {
  2995. LLApp* app = LLApp::instance();
  2996. if(app) return app->getOption(SHARED_SECRET_KEY);
  2997. }
  2998. return g_shared_secret;
  2999. }
  3000. typedef std::map<const char*, LLMessageBuilder*> BuilderMap;
  3001. void LLMessageSystem::newMessageFast(const char *name)
  3002. {
  3003. LLMessageConfig::Flavor message_flavor =
  3004. LLMessageConfig::getMessageFlavor(name);
  3005. LLMessageConfig::Flavor server_flavor =
  3006. LLMessageConfig::getServerDefaultFlavor();
  3007. if(message_flavor == LLMessageConfig::TEMPLATE_FLAVOR)
  3008. {
  3009. mMessageBuilder = mTemplateMessageBuilder;
  3010. }
  3011. else if (message_flavor == LLMessageConfig::LLSD_FLAVOR)
  3012. {
  3013. mMessageBuilder = mLLSDMessageBuilder;
  3014. }
  3015. // NO_FLAVOR
  3016. else
  3017. {
  3018. if (server_flavor == LLMessageConfig::LLSD_FLAVOR)
  3019. {
  3020. mMessageBuilder = mLLSDMessageBuilder;
  3021. }
  3022. // TEMPLATE_FLAVOR or NO_FLAVOR
  3023. else
  3024. {
  3025. mMessageBuilder = mTemplateMessageBuilder;
  3026. }
  3027. }
  3028. mSendReliable = FALSE;
  3029. mMessageBuilder->newMessage(name);
  3030. }
  3031. void LLMessageSystem::newMessage(const char *name)
  3032. {
  3033. newMessageFast(LLMessageStringTable::getInstance()->getString(name));
  3034. }
  3035. void LLMessageSystem::addBinaryDataFast(const char *varname, const void *data, S32 size)
  3036. {
  3037. mMessageBuilder->addBinaryData(varname, data, size);
  3038. }
  3039. void LLMessageSystem::addBinaryData(const char *varname, const void *data, S32 size)
  3040. {
  3041. mMessageBuilder->addBinaryData(LLMessageStringTable::getInstance()->getString(varname),data, size);
  3042. }
  3043. void LLMessageSystem::addS8Fast(const char *varname, S8 v)
  3044. {
  3045. mMessageBuilder->addS8(varname, v);
  3046. }
  3047. void LLMessageSystem::addS8(const char *varname, S8 v)
  3048. {
  3049. mMessageBuilder->addS8(LLMessageStringTable::getInstance()->getString(varname), v);
  3050. }
  3051. void LLMessageSystem::addU8Fast(const char *varname, U8 v)
  3052. {
  3053. mMessageBuilder->addU8(varname, v);
  3054. }
  3055. void LLMessageSystem::addU8(const char *varname, U8 v)
  3056. {
  3057. mMessageBuilder->addU8(LLMessageStringTable::getInstance()->getString(varname), v);
  3058. }
  3059. void LLMessageSystem::addS16Fast(const char *varname, S16 v)
  3060. {
  3061. mMessageBuilder->addS16(varname, v);
  3062. }
  3063. void LLMessageSystem::addS16(const char *varname, S16 v)
  3064. {
  3065. mMessageBuilder->addS16(LLMessageStringTable::getInstance()->getString(varname), v);
  3066. }
  3067. void LLMessageSystem::addU16Fast(const char *varname, U16 v)
  3068. {
  3069. mMessageBuilder->addU16(varname, v);
  3070. }
  3071. void LLMessageSystem::addU16(const char *varname, U16 v)
  3072. {
  3073. mMessageBuilder->addU16(LLMessageStringTable::getInstance()->getString(varname), v);
  3074. }
  3075. void LLMessageSystem::addF32Fast(const char *varname, F32 v)
  3076. {
  3077. mMessageBuilder->addF32(varname, v);
  3078. }
  3079. void LLMessageSystem::addF32(const char *varname, F32 v)
  3080. {
  3081. mMessageBuilder->addF32(LLMessageStringTable::getInstance()->getString(varname), v);
  3082. }
  3083. void LLMessageSystem::addS32Fast(const char *varname, S32 v)
  3084. {
  3085. mMessageBuilder->addS32(varname, v);
  3086. }
  3087. void LLMessageSystem::addS32(const char *varname, S32 v)
  3088. {
  3089. mMessageBuilder->addS32(LLMessageStringTable::getInstance()->getString(varname), v);
  3090. }
  3091. void LLMessageSystem::addU32Fast(const char *varname, U32 v)
  3092. {
  3093. mMessageBuilder->addU32(varname, v);
  3094. }
  3095. void LLMessageSystem::addU32(const char *varname, U32 v)
  3096. {
  3097. mMessageBuilder->addU32(LLMessageStringTable::getInstance()->getString(varname), v);
  3098. }
  3099. void LLMessageSystem::addU64Fast(const char *varname, U64 v)
  3100. {
  3101. mMessageBuilder->addU64(varname, v);
  3102. }
  3103. void LLMessageSystem::addU64(const char *varname, U64 v)
  3104. {
  3105. mMessageBuilder->addU64(LLMessageStringTable::getInstance()->getString(varname), v);
  3106. }
  3107. void LLMessageSystem::addF64Fast(const char *varname, F64 v)
  3108. {
  3109. mMessageBuilder->addF64(varname, v);
  3110. }
  3111. void LLMessageSystem::addF64(const char *varname, F64 v)
  3112. {
  3113. mMessageBuilder->addF64(LLMessageStringTable::getInstance()->getString(varname), v);
  3114. }
  3115. void LLMessageSystem::addIPAddrFast(const char *varname, U32 v)
  3116. {
  3117. mMessageBuilder->addIPAddr(varname, v);
  3118. }
  3119. void LLMessageSystem::addIPAddr(const char *varname, U32 v)
  3120. {
  3121. mMessageBuilder->addIPAddr(LLMessageStringTable::getInstance()->getString(varname), v);
  3122. }
  3123. void LLMessageSystem::addIPPortFast(const char *varname, U16 v)
  3124. {
  3125. mMessageBuilder->addIPPort(varname, v);
  3126. }
  3127. void LLMessageSystem::addIPPort(const char *varname, U16 v)
  3128. {
  3129. mMessageBuilder->addIPPort(LLMessageStringTable::getInstance()->getString(varname), v);
  3130. }
  3131. void LLMessageSystem::addBOOLFast(const char* varname, BOOL v)
  3132. {
  3133. mMessageBuilder->addBOOL(varname, v);
  3134. }
  3135. void LLMessageSystem::addBOOL(const char* varname, BOOL v)
  3136. {
  3137. mMessageBuilder->addBOOL(LLMessageStringTable::getInstance()->getString(varname), v);
  3138. }
  3139. void LLMessageSystem::addStringFast(const char* varname, const char* v)
  3140. {
  3141. mMessageBuilder->addString(varname, v);
  3142. }
  3143. void LLMessageSystem::addString(const char* varname, const char* v)
  3144. {
  3145. mMessageBuilder->addString(LLMessageStringTable::getInstance()->getString(varname), v);
  3146. }
  3147. void LLMessageSystem::addStringFast(const char* varname, const std::string& v)
  3148. {
  3149. mMessageBuilder->addString(varname, v);
  3150. }
  3151. void LLMessageSystem::addString(const char* varname, const std::string& v)
  3152. {
  3153. mMessageBuilder->addString(LLMessageStringTable::getInstance()->getString(varname), v);
  3154. }
  3155. void LLMessageSystem::addVector3Fast(const char *varname, const LLVector3& v)
  3156. {
  3157. mMessageBuilder->addVector3(varname, v);
  3158. }
  3159. void LLMessageSystem::addVector3(const char *varname, const LLVector3& v)
  3160. {
  3161. mMessageBuilder->addVector3(LLMessageStringTable::getInstance()->getString(varname), v);
  3162. }
  3163. void LLMessageSystem::addVector4Fast(const char *varname, const LLVector4& v)
  3164. {
  3165. mMessageBuilder->addVector4(varname, v);
  3166. }
  3167. void LLMessageSystem::addVector4(const char *varname, const LLVector4& v)
  3168. {
  3169. mMessageBuilder->addVector4(LLMessageStringTable::getInstance()->getString(varname), v);
  3170. }
  3171. void LLMessageSystem::addVector3dFast(const char *varname, const LLVector3d& v)
  3172. {
  3173. mMessageBuilder->addVector3d(varname, v);
  3174. }
  3175. void LLMessageSystem::addVector3d(const char *varname, const LLVector3d& v)
  3176. {
  3177. mMessageBuilder->addVector3d(LLMessageStringTable::getInstance()->getString(varname), v);
  3178. }
  3179. void LLMessageSystem::addQuatFast(const char *varname, const LLQuaternion& v)
  3180. {
  3181. mMessageBuilder->addQuat(varname, v);
  3182. }
  3183. void LLMessageSystem::addQuat(const char *varname, const LLQuaternion& v)
  3184. {
  3185. mMessageBuilder->addQuat(LLMessageStringTable::getInstance()->getString(varname), v);
  3186. }
  3187. void LLMessageSystem::addUUIDFast(const char *varname, const LLUUID& v)
  3188. {
  3189. mMessageBuilder->addUUID(varname, v);
  3190. }
  3191. void LLMessageSystem::addUUID(const char *varname, const LLUUID& v)
  3192. {
  3193. mMessageBuilder->addUUID(LLMessageStringTable::getInstance()->getString(varname), v);
  3194. }
  3195. S32 LLMessageSystem::getCurrentSendTotal() const
  3196. {
  3197. return mMessageBuilder->getMessageSize();
  3198. }
  3199. void LLMessageSystem::getS8Fast(const char *block, const char *var, S8 &u, 
  3200. S32 blocknum)
  3201. {
  3202. mMessageReader->getS8(block, var, u, blocknum);
  3203. }
  3204. void LLMessageSystem::getS8(const char *block, const char *var, S8 &u, 
  3205. S32 blocknum)
  3206. {
  3207. getS8Fast(LLMessageStringTable::getInstance()->getString(block), 
  3208.   LLMessageStringTable::getInstance()->getString(var), u, blocknum);
  3209. }
  3210. void LLMessageSystem::getU8Fast(const char *block, const char *var, U8 &u, 
  3211. S32 blocknum)
  3212. {
  3213. mMessageReader->getU8(block, var, u, blocknum);
  3214. }
  3215. void LLMessageSystem::getU8(const char *block, const char *var, U8 &u, 
  3216. S32 blocknum)
  3217. {
  3218. getU8Fast(LLMessageStringTable::getInstance()->getString(block), 
  3219. LLMessageStringTable::getInstance()->getString(var), u, blocknum);
  3220. }
  3221. void LLMessageSystem::getBOOLFast(const char *block, const char *var, BOOL &b,
  3222.   S32 blocknum)
  3223. {
  3224. mMessageReader->getBOOL(block, var, b, blocknum);
  3225. }
  3226. void LLMessageSystem::getBOOL(const char *block, const char *var, BOOL &b, 
  3227.   S32 blocknum)
  3228. {
  3229. getBOOLFast(LLMessageStringTable::getInstance()->getString(block), 
  3230. LLMessageStringTable::getInstance()->getString(var), b, blocknum);
  3231. }
  3232. void LLMessageSystem::getS16Fast(const char *block, const char *var, S16 &d, 
  3233.  S32 blocknum)
  3234. {
  3235. mMessageReader->getS16(block, var, d, blocknum);
  3236. }
  3237. void LLMessageSystem::getS16(const char *block, const char *var, S16 &d, 
  3238.  S32 blocknum)
  3239. {
  3240. getS16Fast(LLMessageStringTable::getInstance()->getString(block), 
  3241.    LLMessageStringTable::getInstance()->getString(var), d, blocknum);
  3242. }
  3243. void LLMessageSystem::getU16Fast(const char *block, const char *var, U16 &d, 
  3244.  S32 blocknum)
  3245. {
  3246. mMessageReader->getU16(block, var, d, blocknum);
  3247. }
  3248. void LLMessageSystem::getU16(const char *block, const char *var, U16 &d, 
  3249.  S32 blocknum)
  3250. {
  3251. getU16Fast(LLMessageStringTable::getInstance()->getString(block), 
  3252.    LLMessageStringTable::getInstance()->getString(var), d, blocknum);
  3253. }
  3254. void LLMessageSystem::getS32Fast(const char *block, const char *var, S32 &d, 
  3255.  S32 blocknum)
  3256. {
  3257. mMessageReader->getS32(block, var, d, blocknum);
  3258. }
  3259. void LLMessageSystem::getS32(const char *block, const char *var, S32 &d, 
  3260.  S32 blocknum)
  3261. {
  3262. getS32Fast(LLMessageStringTable::getInstance()->getString(block), 
  3263.    LLMessageStringTable::getInstance()->getString(var), d, blocknum);
  3264. }
  3265. void LLMessageSystem::getU32Fast(const char *block, const char *var, U32 &d, 
  3266.  S32 blocknum)
  3267. {
  3268. mMessageReader->getU32(block, var, d, blocknum);
  3269. }
  3270. void LLMessageSystem::getU32(const char *block, const char *var, U32 &d, 
  3271.  S32 blocknum)
  3272. {
  3273. getU32Fast(LLMessageStringTable::getInstance()->getString(block), 
  3274. LLMessageStringTable::getInstance()->getString(var), d, blocknum);
  3275. }
  3276. void LLMessageSystem::getU64Fast(const char *block, const char *var, U64 &d, 
  3277.  S32 blocknum)
  3278. {
  3279. mMessageReader->getU64(block, var, d, blocknum);
  3280. }
  3281. void LLMessageSystem::getU64(const char *block, const char *var, U64 &d, 
  3282.  S32 blocknum)
  3283. {
  3284. getU64Fast(LLMessageStringTable::getInstance()->getString(block), 
  3285.    LLMessageStringTable::getInstance()->getString(var), d, blocknum);
  3286. }
  3287. void LLMessageSystem::getBinaryDataFast(const char *blockname, 
  3288. const char *varname, 
  3289. void *datap, S32 size, 
  3290. S32 blocknum, S32 max_size)
  3291. {
  3292. mMessageReader->getBinaryData(blockname, varname, datap, size, blocknum, 
  3293.   max_size);
  3294. }
  3295. void LLMessageSystem::getBinaryData(const char *blockname, 
  3296. const char *varname, 
  3297. void *datap, S32 size, 
  3298. S32 blocknum, S32 max_size)
  3299. {
  3300. getBinaryDataFast(LLMessageStringTable::getInstance()->getString(blockname), 
  3301.   LLMessageStringTable::getInstance()->getString(varname), 
  3302.   datap, size, blocknum, max_size);
  3303. }
  3304. void LLMessageSystem::getF32Fast(const char *block, const char *var, F32 &d, 
  3305.  S32 blocknum)
  3306. {
  3307. mMessageReader->getF32(block, var, d, blocknum);
  3308. }
  3309. void LLMessageSystem::getF32(const char *block, const char *var, F32 &d, 
  3310.  S32 blocknum)
  3311. {
  3312. getF32Fast(LLMessageStringTable::getInstance()->getString(block), 
  3313.    LLMessageStringTable::getInstance()->getString(var), d, blocknum);
  3314. }
  3315. void LLMessageSystem::getF64Fast(const char *block, const char *var, F64 &d, 
  3316.  S32 blocknum)
  3317. {
  3318. mMessageReader->getF64(block, var, d, blocknum);
  3319. }
  3320. void LLMessageSystem::getF64(const char *block, const char *var, F64 &d, 
  3321.  S32 blocknum)
  3322. {
  3323. getF64Fast(LLMessageStringTable::getInstance()->getString(block), 
  3324. LLMessageStringTable::getInstance()->getString(var), d, blocknum);
  3325. }
  3326. void LLMessageSystem::getVector3Fast(const char *block, const char *var, 
  3327.  LLVector3 &v, S32 blocknum )
  3328. {
  3329. mMessageReader->getVector3(block, var, v, blocknum);
  3330. }
  3331. void LLMessageSystem::getVector3(const char *block, const char *var, 
  3332.  LLVector3 &v, S32 blocknum )
  3333. {
  3334. getVector3Fast(LLMessageStringTable::getInstance()->getString(block), 
  3335.    LLMessageStringTable::getInstance()->getString(var), v, blocknum);
  3336. }
  3337. void LLMessageSystem::getVector4Fast(const char *block, const char *var, 
  3338.  LLVector4 &v, S32 blocknum )
  3339. {
  3340. mMessageReader->getVector4(block, var, v, blocknum);
  3341. }
  3342. void LLMessageSystem::getVector4(const char *block, const char *var, 
  3343.  LLVector4 &v, S32 blocknum )
  3344. {
  3345. getVector4Fast(LLMessageStringTable::getInstance()->getString(block), 
  3346.    LLMessageStringTable::getInstance()->getString(var), v, blocknum);
  3347. }
  3348. void LLMessageSystem::getVector3dFast(const char *block, const char *var, 
  3349.   LLVector3d &v, S32 blocknum )
  3350. {
  3351. mMessageReader->getVector3d(block, var, v, blocknum);
  3352. }
  3353. void LLMessageSystem::getVector3d(const char *block, const char *var, 
  3354.   LLVector3d &v, S32 blocknum )
  3355. {
  3356. getVector3dFast(LLMessageStringTable::getInstance()->getString(block), 
  3357. LLMessageStringTable::getInstance()->getString(var), v, blocknum);
  3358. }
  3359. void LLMessageSystem::getQuatFast(const char *block, const char *var, 
  3360.   LLQuaternion &q, S32 blocknum )
  3361. {
  3362. mMessageReader->getQuat(block, var, q, blocknum);
  3363. }
  3364. void LLMessageSystem::getQuat(const char *block, const char *var, 
  3365.   LLQuaternion &q, S32 blocknum)
  3366. {
  3367. getQuatFast(LLMessageStringTable::getInstance()->getString(block), 
  3368. LLMessageStringTable::getInstance()->getString(var), q, blocknum);
  3369. }
  3370. void LLMessageSystem::getUUIDFast(const char *block, const char *var, 
  3371.   LLUUID &u, S32 blocknum )
  3372. {
  3373. mMessageReader->getUUID(block, var, u, blocknum);
  3374. }
  3375. void LLMessageSystem::getUUID(const char *block, const char *var, LLUUID &u, 
  3376.   S32 blocknum )
  3377. {
  3378. getUUIDFast(LLMessageStringTable::getInstance()->getString(block), 
  3379. LLMessageStringTable::getInstance()->getString(var), u, blocknum);
  3380. }
  3381. void LLMessageSystem::getIPAddrFast(const char *block, const char *var, 
  3382. U32 &u, S32 blocknum)
  3383. {
  3384. mMessageReader->getIPAddr(block, var, u, blocknum);
  3385. }
  3386. void LLMessageSystem::getIPAddr(const char *block, const char *var, U32 &u, 
  3387. S32 blocknum)
  3388. {
  3389. getIPAddrFast(LLMessageStringTable::getInstance()->getString(block), 
  3390.   LLMessageStringTable::getInstance()->getString(var), u, blocknum);
  3391. }
  3392. void LLMessageSystem::getIPPortFast(const char *block, const char *var, 
  3393. U16 &u, S32 blocknum)
  3394. {
  3395. mMessageReader->getIPPort(block, var, u, blocknum);
  3396. }
  3397. void LLMessageSystem::getIPPort(const char *block, const char *var, U16 &u, 
  3398. S32 blocknum)
  3399. {
  3400. getIPPortFast(LLMessageStringTable::getInstance()->getString(block), 
  3401.   LLMessageStringTable::getInstance()->getString(var), u, 
  3402.   blocknum);
  3403. }
  3404. void LLMessageSystem::getStringFast(const char *block, const char *var, 
  3405. S32 buffer_size, char *s, S32 blocknum)
  3406. {
  3407. if(buffer_size <= 0)
  3408. {
  3409. LL_WARNS("Messaging") << "buffer_size <= 0" << llendl;
  3410. }
  3411. mMessageReader->getString(block, var, buffer_size, s, blocknum);
  3412. }
  3413. void LLMessageSystem::getString(const char *block, const char *var, 
  3414. S32 buffer_size, char *s, S32 blocknum )
  3415. {
  3416. getStringFast(LLMessageStringTable::getInstance()->getString(block), 
  3417.   LLMessageStringTable::getInstance()->getString(var), buffer_size, s, 
  3418.   blocknum);
  3419. }
  3420. void LLMessageSystem::getStringFast(const char *block, const char *var, 
  3421. std::string& outstr, S32 blocknum)
  3422. {
  3423. mMessageReader->getString(block, var, outstr, blocknum);
  3424. }
  3425. void LLMessageSystem::getString(const char *block, const char *var, 
  3426. std::string& outstr, S32 blocknum )
  3427. {
  3428. getStringFast(LLMessageStringTable::getInstance()->getString(block), 
  3429.   LLMessageStringTable::getInstance()->getString(var), outstr, 
  3430.   blocknum);
  3431. }
  3432. BOOL LLMessageSystem::has(const char *blockname) const
  3433. {
  3434. return getNumberOfBlocks(blockname) > 0;
  3435. }
  3436. S32 LLMessageSystem::getNumberOfBlocksFast(const char *blockname) const
  3437. {
  3438. return mMessageReader->getNumberOfBlocks(blockname);
  3439. }
  3440. S32 LLMessageSystem::getNumberOfBlocks(const char *blockname) const
  3441. {
  3442. return getNumberOfBlocksFast(LLMessageStringTable::getInstance()->getString(blockname));
  3443. }
  3444. S32 LLMessageSystem::getSizeFast(const char *blockname, const char *varname) const
  3445. {
  3446. return mMessageReader->getSize(blockname, varname);
  3447. }
  3448. S32 LLMessageSystem::getSize(const char *blockname, const char *varname) const
  3449. {
  3450. return getSizeFast(LLMessageStringTable::getInstance()->getString(blockname), 
  3451.    LLMessageStringTable::getInstance()->getString(varname));
  3452. }
  3453. // size in bytes of variable length data
  3454. S32 LLMessageSystem::getSizeFast(const char *blockname, S32 blocknum, 
  3455.  const char *varname) const
  3456. {
  3457. return mMessageReader->getSize(blockname, blocknum, varname);
  3458. }
  3459. S32 LLMessageSystem::getSize(const char *blockname, S32 blocknum, 
  3460.  const char *varname) const
  3461. {
  3462. return getSizeFast(LLMessageStringTable::getInstance()->getString(blockname), blocknum, 
  3463.    LLMessageStringTable::getInstance()->getString(varname));
  3464. }
  3465. S32 LLMessageSystem::getReceiveSize() const
  3466. {
  3467. return mMessageReader->getMessageSize();
  3468. }
  3469. //static 
  3470. void LLMessageSystem::setTimeDecodes( BOOL b )
  3471. {
  3472. LLMessageReader::setTimeDecodes(b);
  3473. }
  3474. //static 
  3475. void LLMessageSystem::setTimeDecodesSpamThreshold( F32 seconds )
  3476. LLMessageReader::setTimeDecodesSpamThreshold(seconds);
  3477. }
  3478. // HACK! babbage: return true if message rxed via either UDP or HTTP
  3479. // TODO: babbage: move gServicePump in to LLMessageSystem?
  3480. bool LLMessageSystem::checkAllMessages(S64 frame_count, LLPumpIO* http_pump)
  3481. {
  3482. LLMemType mt_cam(LLMemType::MTYPE_MESSAGE_CHECK_ALL);
  3483. if(checkMessages(frame_count))
  3484. {
  3485. return true;
  3486. }
  3487. U32 packetsIn = mPacketsIn;
  3488. http_pump->pump();
  3489. http_pump->callback();
  3490. return (mPacketsIn - packetsIn) > 0;
  3491. }
  3492. void LLMessageSystem::banUdpMessage(const std::string& name)
  3493. {
  3494. message_template_name_map_t::iterator itt = mMessageTemplates.find(
  3495. LLMessageStringTable::getInstance()->getString(name.c_str())
  3496. );
  3497. if(itt != mMessageTemplates.end())
  3498. {
  3499. itt->second->banUdp();
  3500. }
  3501. else
  3502. {
  3503. llwarns << "Attempted to ban an unknown message: " << name << "." << llendl;
  3504. }
  3505. }
  3506. const LLHost& LLMessageSystem::getSender() const
  3507. {
  3508. return mLastSender;
  3509. }
  3510. LLHTTPRegistration<LLHTTPNodeAdapter<LLTrustedMessageService> >
  3511. gHTTPRegistrationTrustedMessageWildcard("/trusted-message/<message-name>");