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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file message.h
  3.  * @brief LLMessageSystem class header file
  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. #ifndef LL_MESSAGE_H
  33. #define LL_MESSAGE_H
  34. #include <cstring>
  35. #include <set>
  36. #if LL_LINUX
  37. #include <endian.h>
  38. #include <netinet/in.h>
  39. #endif
  40. #if LL_SOLARIS
  41. #include <netinet/in.h>
  42. #endif
  43. #if LL_WINDOWS
  44. #include "winsock2.h" // htons etc.
  45. #endif
  46. #include "llerror.h"
  47. #include "net.h"
  48. #include "string_table.h"
  49. #include "llcircuit.h"
  50. #include "lltimer.h"
  51. #include "llpacketring.h"
  52. #include "llhost.h"
  53. #include "llhttpclient.h"
  54. #include "llhttpnode.h"
  55. #include "llpacketack.h"
  56. #include "llsingleton.h"
  57. #include "message_prehash.h"
  58. #include "llstl.h"
  59. #include "llmsgvariabletype.h"
  60. #include "llmessagesenderinterface.h"
  61. #include "llstoredmessage.h"
  62. const U32 MESSAGE_MAX_STRINGS_LENGTH = 64;
  63. const U32 MESSAGE_NUMBER_OF_HASH_BUCKETS = 8192;
  64. const S32 MESSAGE_MAX_PER_FRAME = 400;
  65. class LLMessageStringTable : public LLSingleton<LLMessageStringTable>
  66. {
  67. public:
  68. LLMessageStringTable();
  69. ~LLMessageStringTable();
  70. char *getString(const char *str);
  71. U32  mUsed;
  72. BOOL mEmpty[MESSAGE_NUMBER_OF_HASH_BUCKETS];
  73. char mString[MESSAGE_NUMBER_OF_HASH_BUCKETS][MESSAGE_MAX_STRINGS_LENGTH]; /* Flawfinder: ignore */
  74. };
  75. // Individual Messages are described with the following format
  76. // Note that to ease parsing, keywords are used
  77. //
  78. // // Comment  (Comment like a C++ single line comment)
  79. //   Comments can only be placed between Messages
  80. // {
  81. // MessageName (same naming restrictions as C variable)
  82. // Frequency ("High", "Medium", or "Low" - determines whether message ID is 8, 16, or 32-bits -- 
  83. //  there can 254 messages in the first 2 groups, 32K in the last group)
  84. // (A message can be made up only of the Name if it is only a signal)
  85. // Trust ("Trusted", "NotTrusted" - determines if a message will be accepted
  86. //  on a circuit.  "Trusted" messages are not accepted from NotTrusted circuits
  87. //  while NotTrusted messages are accepted on any circuit.  An example of a
  88. //  NotTrusted circuit is any circuit from the viewer.)
  89. // Encoding ("Zerocoded", "Unencoded" - zerocoded messages attempt to compress sequences of 
  90. //  zeros, but if there is no space win, it discards the compression and goes unencoded)
  91. // {
  92. // Block Name (same naming restrictions as C variable)
  93. // Block Type ("Single", "Multiple", or "Variable" - determines if the block is coded once, 
  94. //  a known number of times, or has a 8 bit argument encoded to tell the decoder 
  95. //  how many times the group is repeated)
  96. // Block Repeat Number (Optional - used only with the "Multiple" type - tells how many times the field is repeated
  97. // {
  98. // Variable 1 Name (same naming restrictions as C variable)
  99. // Variable Type ("Fixed" or "Variable" - determines if the variable is of fixed size or needs to 
  100. //  encode an argument describing the size in bytes)
  101. // Variable Size (In bytes, either of the "Fixed" variable itself or of the size argument)
  102. //
  103. // repeat variables
  104. //
  105. // }
  106. //
  107. // Repeat for number of variables in block
  108. // }
  109. //
  110. // Repeat for number of blocks in message
  111. // }
  112. // Repeat for number of messages in file
  113. //
  114. // Constants
  115. const S32 MAX_MESSAGE_INTERNAL_NAME_SIZE = 255;
  116. const S32 MAX_BUFFER_SIZE = NET_BUFFER_SIZE;
  117. const S32 MAX_BLOCKS = 255;
  118. const U8 LL_ZERO_CODE_FLAG = 0x80;
  119. const U8 LL_RELIABLE_FLAG = 0x40;
  120. const U8 LL_RESENT_FLAG = 0x20;
  121. const U8 LL_ACK_FLAG = 0x10;
  122. // 1 byte flags, 4 bytes sequence, 1 byte offset + 1 byte message name (high)
  123. const S32 LL_MINIMUM_VALID_PACKET_SIZE = LL_PACKET_ID_SIZE + 1;
  124. enum EPacketHeaderLayout
  125. {
  126. PHL_FLAGS = 0,
  127. PHL_PACKET_ID = 1,
  128. PHL_OFFSET = 5,
  129. PHL_NAME = 6
  130. };
  131. const S32 LL_DEFAULT_RELIABLE_RETRIES = 3;
  132. const F32 LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS = 1.f;
  133. const F32 LL_MINIMUM_SEMIRELIABLE_TIMEOUT_SECONDS = 1.f;
  134. const F32 LL_PING_BASED_TIMEOUT_DUMMY = 0.0f;
  135. // *NOTE: Maybe these factors shouldn't include the msec to sec conversion
  136. // implicitly.
  137. // However, all units should be MKS.
  138. const F32 LL_SEMIRELIABLE_TIMEOUT_FACTOR = 5.f / 1000.f; // factor * averaged ping
  139. const F32 LL_RELIABLE_TIMEOUT_FACTOR = 5.f / 1000.f;      // factor * averaged ping
  140. const F32 LL_FILE_XFER_TIMEOUT_FACTOR = 5.f / 1000.f;      // factor * averaged ping
  141. const F32 LL_LOST_TIMEOUT_FACTOR = 16.f / 1000.f;     // factor * averaged ping for marking packets "Lost"
  142. const F32 LL_MAX_LOST_TIMEOUT = 5.f; // Maximum amount of time before considering something "lost"
  143. const S32 MAX_MESSAGE_COUNT_NUM = 1024;
  144. // Forward declarations
  145. class LLCircuit;
  146. class LLVector3;
  147. class LLVector4;
  148. class LLVector3d;
  149. class LLQuaternion;
  150. class LLSD;
  151. class LLUUID;
  152. class LLMessageSystem;
  153. class LLPumpIO;
  154. // message system exceptional condition handlers.
  155. enum EMessageException
  156. {
  157. MX_UNREGISTERED_MESSAGE, // message number not part of template
  158. MX_PACKET_TOO_SHORT, // invalid packet, shorter than minimum packet size
  159. MX_RAN_OFF_END_OF_PACKET, // ran off the end of the packet during decode
  160. MX_WROTE_PAST_BUFFER_SIZE // wrote past buffer size in zero code expand
  161. };
  162. typedef void (*msg_exception_callback)(LLMessageSystem*,void*,EMessageException);
  163. // message data pieces are used to collect the data called for by the message template
  164. class LLMsgData;
  165. class LLMsgBlkData;
  166. class LLMessageTemplate;
  167. class LLMessagePollInfo;
  168. class LLMessageBuilder;
  169. class LLTemplateMessageBuilder;
  170. class LLSDMessageBuilder;
  171. class LLMessageReader;
  172. class LLTemplateMessageReader;
  173. class LLSDMessageReader;
  174. class LLUseCircuitCodeResponder
  175. {
  176. LOG_CLASS(LLMessageSystem);
  177. public:
  178. virtual ~LLUseCircuitCodeResponder();
  179. virtual void complete(const LLHost& host, const LLUUID& agent) const = 0;
  180. };
  181. class LLMessageSystem : public LLMessageSenderInterface
  182. {
  183.  private:
  184. U8 mSendBuffer[MAX_BUFFER_SIZE];
  185. S32 mSendSize;
  186. bool mBlockUntrustedInterface;
  187. LLHost mUntrustedInterface;
  188.  public:
  189. LLPacketRing mPacketRing;
  190. LLReliablePacketParams mReliablePacketParams;
  191. // Set this flag to TRUE when you want *very* verbose logs.
  192. BOOL mVerboseLog;
  193. F32                                     mMessageFileVersionNumber;
  194. typedef std::map<const char *, LLMessageTemplate*> message_template_name_map_t;
  195. typedef std::map<U32, LLMessageTemplate*> message_template_number_map_t;
  196. private:
  197. message_template_name_map_t mMessageTemplates;
  198. message_template_number_map_t mMessageNumbers;
  199. public:
  200. S32 mSystemVersionMajor;
  201. S32 mSystemVersionMinor;
  202. S32 mSystemVersionPatch;
  203. S32 mSystemVersionServer;
  204. U32 mVersionFlags;
  205. BOOL mbProtected;
  206. U32 mNumberHighFreqMessages;
  207. U32 mNumberMediumFreqMessages;
  208. U32 mNumberLowFreqMessages;
  209. S32 mPort;
  210. S32 mSocket;
  211. U32 mPacketsIn;     // total packets in, including compressed and uncompressed
  212. U32 mPacketsOut;     // total packets out, including compressed and uncompressed
  213. U64 mBytesIn;     // total bytes in, including compressed and uncompressed
  214. U64 mBytesOut;     // total bytes out, including compressed and uncompressed
  215. U32 mCompressedPacketsIn;     // total compressed packets in
  216. U32 mCompressedPacketsOut;     // total compressed packets out
  217. U32 mReliablePacketsIn;     // total reliable packets in
  218. U32 mReliablePacketsOut;     // total reliable packets out
  219. U32                                     mDroppedPackets;            // total dropped packets in
  220. U32                                     mResentPackets;             // total resent packets out
  221. U32                                     mFailedResendPackets;       // total resend failure packets out
  222. U32                                     mOffCircuitPackets;         // total # of off-circuit packets rejected
  223. U32                                     mInvalidOnCircuitPackets;   // total # of on-circuit but invalid packets rejected
  224. S64 mUncompressedBytesIn;     // total uncompressed size of compressed packets in
  225. S64 mUncompressedBytesOut;     // total uncompressed size of compressed packets out
  226. S64 mCompressedBytesIn;     // total compressed size of compressed packets in
  227. S64 mCompressedBytesOut;     // total compressed size of compressed packets out
  228. S64 mTotalBytesIn;     // total size of all uncompressed packets in
  229. S64 mTotalBytesOut;     // total size of all uncompressed packets out
  230. BOOL                                    mSendReliable;              // does the outgoing message require a pos ack?
  231. LLCircuit    mCircuitInfo;
  232. F64 mCircuitPrintTime;     // used to print circuit debug info every couple minutes
  233. F32 mCircuitPrintFreq;     // seconds
  234. std::map<U64, U32> mIPPortToCircuitCode;
  235. std::map<U32, U64> mCircuitCodeToIPPort;
  236. U32 mOurCircuitCode;
  237. S32 mSendPacketFailureCount;
  238. S32 mUnackedListDepth;
  239. S32 mUnackedListSize;
  240. S32 mDSMaxListDepth;
  241. public:
  242. // Read file and build message templates
  243. LLMessageSystem(const std::string& filename, U32 port, S32 version_major,
  244. S32 version_minor, S32 version_patch,
  245. bool failure_is_fatal,
  246. const F32 circuit_heartbeat_interval, const F32 circuit_timeout);
  247. ~LLMessageSystem();
  248. BOOL isOK() const { return !mbError; }
  249. S32 getErrorCode() const { return mErrorCode; }
  250. // Read file and build message templates filename must point to a
  251. // valid string which specifies the path of a valid linden
  252. // template.
  253. void loadTemplateFile(const std::string& filename, bool failure_is_fatal);
  254. // methods for building, sending, receiving, and handling messages
  255. void setHandlerFuncFast(const char *name, void (*handler_func)(LLMessageSystem *msgsystem, void **user_data), void **user_data = NULL);
  256. void setHandlerFunc(const char *name, void (*handler_func)(LLMessageSystem *msgsystem, void **user_data), void **user_data = NULL)
  257. {
  258. setHandlerFuncFast(LLMessageStringTable::getInstance()->getString(name), handler_func, user_data);
  259. }
  260. // Set a callback function for a message system exception.
  261. void setExceptionFunc(EMessageException exception, msg_exception_callback func, void* data = NULL);
  262. // Call the specified exception func, and return TRUE if a
  263. // function was found and called. Otherwise return FALSE.
  264. BOOL callExceptionFunc(EMessageException exception);
  265. // Set a function that will be called once per packet processed with the 
  266. // hashed message name and the time spent in the processing handler function
  267. // measured in seconds.  JC
  268. typedef void (*msg_timing_callback)(const char* hashed_name, F32 time, void* data);
  269. void setTimingFunc(msg_timing_callback func, void* data = NULL);
  270. msg_timing_callback getTimingCallback() 
  271. return mTimingCallback; 
  272. }
  273. void* getTimingCallbackData() 
  274. {
  275. return mTimingCallbackData;
  276. }
  277. // This method returns true if the code is in the circuit codes map.
  278. BOOL isCircuitCodeKnown(U32 code) const;
  279. // usually called in response to an AddCircuitCode message, but
  280. // may also be called by the login process.
  281. bool addCircuitCode(U32 code, const LLUUID& session_id);
  282. BOOL poll(F32 seconds); // Number of seconds that we want to block waiting for data, returns if data was received
  283. BOOL checkMessages( S64 frame_count = 0 );
  284. void processAcks();
  285. BOOL isMessageFast(const char *msg);
  286. BOOL isMessage(const char *msg)
  287. {
  288. return isMessageFast(LLMessageStringTable::getInstance()->getString(msg));
  289. }
  290. void dumpPacketToLog();
  291. char *getMessageName();
  292. const LLHost& getSender() const;
  293. U32 getSenderIP() const; // getSender() is preferred
  294. U32 getSenderPort() const; // getSender() is preferred
  295. const LLHost& getReceivingInterface() const;
  296. // This method returns the uuid associated with the sender. The
  297. // UUID will be null if it is not yet known or is a server
  298. // circuit.
  299. const LLUUID& getSenderID() const;
  300. // This method returns the session id associated with the last
  301. // sender.
  302. const LLUUID& getSenderSessionID() const;
  303. // set & get the session id (useful for viewers for now.)
  304. void setMySessionID(const LLUUID& session_id) { mSessionID = session_id; }
  305. const LLUUID& getMySessionID() { return mSessionID; }
  306. void newMessageFast(const char *name);
  307. void newMessage(const char *name);
  308. public:
  309. LLStoredMessagePtr getReceivedMessage() const; 
  310. LLStoredMessagePtr getBuiltMessage() const;
  311. S32 sendMessage(const LLHost &host, LLStoredMessagePtr message);
  312. private:
  313. LLSD getReceivedMessageLLSD() const;
  314. LLSD getBuiltMessageLLSD() const;
  315. // NOTE: babbage: Only use to support legacy misuse of the
  316. // LLMessageSystem API where values are dangerously written
  317. // as one type and read as another. LLSD does not support
  318. // dangerous conversions and so converting the message to an
  319. // LLSD would result in the reads failing. All code which
  320. // misuses the message system in this way should be made safe
  321. // but while the unsafe code is run in old processes, this
  322. // method should be used to forward unsafe messages.
  323. LLSD wrapReceivedTemplateData() const;
  324. LLSD wrapBuiltTemplateData() const;
  325. public:
  326. void copyMessageReceivedToSend();
  327. void clearMessage();
  328. void nextBlockFast(const char *blockname);
  329. void nextBlock(const char *blockname);
  330. public:
  331. void addBinaryDataFast(const char *varname, const void *data, S32 size);
  332. void addBinaryData(const char *varname, const void *data, S32 size);
  333. void addBOOLFast( const char* varname, BOOL b); // typed, checks storage space
  334. void addBOOL( const char* varname, BOOL b); // typed, checks storage space
  335. void addS8Fast( const char *varname, S8 s); // typed, checks storage space
  336. void addS8( const char *varname, S8 s); // typed, checks storage space
  337. void addU8Fast( const char *varname, U8 u); // typed, checks storage space
  338. void addU8( const char *varname, U8 u); // typed, checks storage space
  339. void addS16Fast( const char *varname, S16 i); // typed, checks storage space
  340. void addS16( const char *varname, S16 i); // typed, checks storage space
  341. void addU16Fast( const char *varname, U16 i); // typed, checks storage space
  342. void addU16( const char *varname, U16 i); // typed, checks storage space
  343. void addF32Fast( const char *varname, F32 f); // typed, checks storage space
  344. void addF32( const char *varname, F32 f); // typed, checks storage space
  345. void addS32Fast( const char *varname, S32 s); // typed, checks storage space
  346. void addS32( const char *varname, S32 s); // typed, checks storage space
  347. void addU32Fast( const char *varname, U32 u); // typed, checks storage space
  348. void addU32( const char *varname, U32 u); // typed, checks storage space
  349. void addU64Fast( const char *varname, U64 lu); // typed, checks storage space
  350. void addU64( const char *varname, U64 lu); // typed, checks storage space
  351. void addF64Fast( const char *varname, F64 d); // typed, checks storage space
  352. void addF64( const char *varname, F64 d); // typed, checks storage space
  353. void addVector3Fast( const char *varname, const LLVector3& vec); // typed, checks storage space
  354. void addVector3( const char *varname, const LLVector3& vec); // typed, checks storage space
  355. void addVector4Fast( const char *varname, const LLVector4& vec); // typed, checks storage space
  356. void addVector4( const char *varname, const LLVector4& vec); // typed, checks storage space
  357. void addVector3dFast( const char *varname, const LLVector3d& vec); // typed, checks storage space
  358. void addVector3d( const char *varname, const LLVector3d& vec); // typed, checks storage space
  359. void addQuatFast( const char *varname, const LLQuaternion& quat); // typed, checks storage space
  360. void addQuat( const char *varname, const LLQuaternion& quat); // typed, checks storage space
  361. void addUUIDFast( const char *varname, const LLUUID& uuid); // typed, checks storage space
  362. void addUUID( const char *varname, const LLUUID& uuid); // typed, checks storage space
  363. void addIPAddrFast( const char *varname, const U32 ip); // typed, checks storage space
  364. void addIPAddr( const char *varname, const U32 ip); // typed, checks storage space
  365. void addIPPortFast( const char *varname, const U16 port); // typed, checks storage space
  366. void addIPPort( const char *varname, const U16 port); // typed, checks storage space
  367. void addStringFast( const char* varname, const char* s); // typed, checks storage space
  368. void addString( const char* varname, const char* s); // typed, checks storage space
  369. void addStringFast( const char* varname, const std::string& s); // typed, checks storage space
  370. void addString( const char* varname, const std::string& s); // typed, checks storage space
  371. S32 getCurrentSendTotal() const;
  372. TPACKETID getCurrentRecvPacketID() { return mCurrentRecvPacketID; }
  373. // This method checks for current send total and returns true if
  374. // you need to go to the next block type or need to start a new
  375. // message. Specify the current blockname to check block counts,
  376. // otherwise the method only checks against MTU.
  377. BOOL isSendFull(const char* blockname = NULL);
  378. BOOL isSendFullFast(const char* blockname = NULL);
  379. BOOL removeLastBlock();
  380. //void buildMessage();
  381. S32     zeroCode(U8 **data, S32 *data_size);
  382. S32 zeroCodeExpand(U8 **data, S32 *data_size);
  383. S32 zeroCodeAdjustCurrentSendTotal();
  384. // Uses ping-based retry
  385. S32 sendReliable(const LLHost &host);
  386. // Uses ping-based retry
  387. S32 sendReliable(const U32 circuit) { return sendReliable(findHost(circuit)); }
  388. // Use this one if you DON'T want automatic ping-based retry.
  389. S32 sendReliable( const LLHost &host, 
  390. S32 retries, 
  391. BOOL ping_based_retries,
  392. F32 timeout, 
  393. void (*callback)(void **,S32), 
  394. void ** callback_data);
  395. S32 sendSemiReliable( const LLHost &host, 
  396. void (*callback)(void **,S32), void ** callback_data);
  397. // flush sends a message only if data's been pushed on it.
  398. S32  flushSemiReliable( const LLHost &host, 
  399. void (*callback)(void **,S32), void ** callback_data);
  400. S32 flushReliable( const LLHost &host );
  401. void forwardMessage(const LLHost &host);
  402. void forwardReliable(const LLHost &host);
  403. void forwardReliable(const U32 circuit_code);
  404. S32 forwardReliable(
  405. const LLHost &host, 
  406. S32 retries, 
  407. BOOL ping_based_timeout,
  408. F32 timeout, 
  409. void (*callback)(void **,S32), 
  410. void ** callback_data);
  411. LLHTTPClient::ResponderPtr createResponder(const std::string& name);
  412. S32 sendMessage(const LLHost &host);
  413. S32 sendMessage(const U32 circuit);
  414. private:
  415. S32 sendMessage(const LLHost &host, const char* name,
  416. const LLSD& message);
  417. public:
  418. // BOOL decodeData(const U8 *buffer, const LLHost &host);
  419. /**
  420. gets binary data from the current message.
  421. @param blockname the name of the block in the message (from the message template)
  422. @param varname 
  423. @param datap
  424. @param size expected size - set to zero to get any amount of data up to max_size.
  425. Make sure max_size is set in that case!
  426. @param blocknum
  427. @param max_size the max number of bytes to read
  428. */
  429. void getBinaryDataFast(const char *blockname, const char *varname, void *datap, S32 size, S32 blocknum = 0, S32 max_size = S32_MAX);
  430. void getBinaryData(const char *blockname, const char *varname, void *datap, S32 size, S32 blocknum = 0, S32 max_size = S32_MAX);
  431. void getBOOLFast( const char *block, const char *var, BOOL &data, S32 blocknum = 0);
  432. void getBOOL( const char *block, const char *var, BOOL &data, S32 blocknum = 0);
  433. void getS8Fast( const char *block, const char *var, S8 &data, S32 blocknum = 0);
  434. void getS8( const char *block, const char *var, S8 &data, S32 blocknum = 0);
  435. void getU8Fast( const char *block, const char *var, U8 &data, S32 blocknum = 0);
  436. void getU8( const char *block, const char *var, U8 &data, S32 blocknum = 0);
  437. void getS16Fast( const char *block, const char *var, S16 &data, S32 blocknum = 0);
  438. void getS16( const char *block, const char *var, S16 &data, S32 blocknum = 0);
  439. void getU16Fast( const char *block, const char *var, U16 &data, S32 blocknum = 0);
  440. void getU16( const char *block, const char *var, U16 &data, S32 blocknum = 0);
  441. void getS32Fast( const char *block, const char *var, S32 &data, S32 blocknum = 0);
  442. void getS32( const char *block, const char *var, S32 &data, S32 blocknum = 0);
  443. void getF32Fast( const char *block, const char *var, F32 &data, S32 blocknum = 0);
  444. void getF32( const char *block, const char *var, F32 &data, S32 blocknum = 0);
  445. void getU32Fast( const char *block, const char *var, U32 &data, S32 blocknum = 0);
  446. void getU32( const char *block, const char *var, U32 &data, S32 blocknum = 0);
  447. void getU64Fast( const char *block, const char *var, U64 &data, S32 blocknum = 0);
  448. void getU64( const char *block, const char *var, U64 &data, S32 blocknum = 0);
  449. void getF64Fast( const char *block, const char *var, F64 &data, S32 blocknum = 0);
  450. void getF64( const char *block, const char *var, F64 &data, S32 blocknum = 0);
  451. void getVector3Fast( const char *block, const char *var, LLVector3 &vec, S32 blocknum = 0);
  452. void getVector3( const char *block, const char *var, LLVector3 &vec, S32 blocknum = 0);
  453. void getVector4Fast( const char *block, const char *var, LLVector4 &vec, S32 blocknum = 0);
  454. void getVector4( const char *block, const char *var, LLVector4 &vec, S32 blocknum = 0);
  455. void getVector3dFast(const char *block, const char *var, LLVector3d &vec, S32 blocknum = 0);
  456. void getVector3d(const char *block, const char *var, LLVector3d &vec, S32 blocknum = 0);
  457. void getQuatFast( const char *block, const char *var, LLQuaternion &q, S32 blocknum = 0);
  458. void getQuat( const char *block, const char *var, LLQuaternion &q, S32 blocknum = 0);
  459. void getUUIDFast( const char *block, const char *var, LLUUID &uuid, S32 blocknum = 0);
  460. void getUUID( const char *block, const char *var, LLUUID &uuid, S32 blocknum = 0);
  461. void getIPAddrFast( const char *block, const char *var, U32 &ip, S32 blocknum = 0);
  462. void getIPAddr( const char *block, const char *var, U32 &ip, S32 blocknum = 0);
  463. void getIPPortFast( const char *block, const char *var, U16 &port, S32 blocknum = 0);
  464. void getIPPort( const char *block, const char *var, U16 &port, S32 blocknum = 0);
  465. void getStringFast( const char *block, const char *var, S32 buffer_size, char *buffer, S32 blocknum = 0);
  466. void getString( const char *block, const char *var, S32 buffer_size, char *buffer, S32 blocknum = 0);
  467. void getStringFast( const char *block, const char *var, std::string& outstr, S32 blocknum = 0);
  468. void getString( const char *block, const char *var, std::string& outstr, S32 blocknum = 0);
  469. // Utility functions to generate a replay-resistant digest check
  470. // against the shared secret. The window specifies how much of a
  471. // time window is allowed - 1 second is good for tight
  472. // connections, but multi-process windows might want to be upwards
  473. // of 5 seconds. For generateDigest, you want to pass in a
  474. // character array of at least MD5HEX_STR_SIZE so that the hex
  475. // digest and null termination will fit.
  476. bool generateDigestForNumberAndUUIDs(char* digest, const U32 number, const LLUUID &id1, const LLUUID &id2) const;
  477. bool generateDigestForWindowAndUUIDs(char* digest, const S32 window, const LLUUID &id1, const LLUUID &id2) const;
  478. bool isMatchingDigestForWindowAndUUIDs(const char* digest, const S32 window, const LLUUID &id1, const LLUUID &id2) const;
  479. bool generateDigestForNumber(char* digest, const U32 number) const;
  480. bool generateDigestForWindow(char* digest, const S32 window) const;
  481. bool isMatchingDigestForWindow(const char* digest, const S32 window) const;
  482. void showCircuitInfo();
  483. void getCircuitInfo(LLSD& info) const;
  484. U32 getOurCircuitCode();
  485. void enableCircuit(const LLHost &host, BOOL trusted);
  486. void disableCircuit(const LLHost &host);
  487. // Use this to establish trust on startup and in response to
  488. // DenyTrustedCircuit.
  489. void sendCreateTrustedCircuit(const LLHost& host, const LLUUID & id1, const LLUUID & id2);
  490. // Use this to inform a peer that they aren't currently trusted...
  491. // This now enqueues the request so that we can ensure that we only send
  492. // one deny per circuit per message loop so that this doesn't become a DoS.
  493. // The actual sending is done by reallySendDenyTrustedCircuit()
  494. void sendDenyTrustedCircuit(const LLHost &host);
  495. /** Return false if host is unknown or untrusted */
  496. // Note:DaveH/Babbage some trusted messages can be received without a circuit
  497. bool isTrustedSender(const LLHost& host) const;
  498. /** Return true if current message is from trusted source */
  499. bool isTrustedSender() const;
  500. /** Return false true if name is unknown or untrusted */
  501. bool isTrustedMessage(const std::string& name) const;
  502. /** Return false true if name is unknown or trusted */
  503. bool isUntrustedMessage(const std::string& name) const;
  504. // Mark an interface ineligible for trust
  505. void setUntrustedInterface( const LLHost host ) { mUntrustedInterface = host; }
  506. LLHost getUntrustedInterface() const { return mUntrustedInterface; }
  507. void setBlockUntrustedInterface( bool block ) { mBlockUntrustedInterface = block; } // Throw a switch to allow, sending warnings only
  508. bool getBlockUntrustedInterface() const { return mBlockUntrustedInterface; }
  509. // Change this message to be UDP black listed.
  510. void banUdpMessage(const std::string& name);
  511. private:
  512. // A list of the circuits that need to be sent DenyTrustedCircuit messages.
  513. typedef std::set<LLHost> host_set_t;
  514. host_set_t mDenyTrustedCircuitSet;
  515. // Really sends the DenyTrustedCircuit message to a given host
  516. // related to sendDenyTrustedCircuit()
  517. void reallySendDenyTrustedCircuit(const LLHost &host);
  518. public:
  519. // Use this to establish trust to and from a host.  This blocks
  520. // until trust has been established, and probably should only be
  521. // used on startup.
  522. void establishBidirectionalTrust(const LLHost &host, S64 frame_count = 0);
  523. // returns whether the given host is on a trusted circuit
  524. // Note:DaveH/Babbage some trusted messages can be received without a circuit
  525. BOOL    getCircuitTrust(const LLHost &host);
  526. void setCircuitAllowTimeout(const LLHost &host, BOOL allow);
  527. void setCircuitTimeoutCallback(const LLHost &host, void (*callback_func)(const LLHost &host, void *user_data), void *user_data);
  528. BOOL checkCircuitBlocked(const U32 circuit);
  529. BOOL checkCircuitAlive(const U32 circuit);
  530. BOOL checkCircuitAlive(const LLHost &host);
  531. void setCircuitProtection(BOOL b_protect);
  532. U32 findCircuitCode(const LLHost &host);
  533. LLHost findHost(const U32 circuit_code);
  534. void sanityCheck();
  535. BOOL has(const char *blockname) const;
  536. S32 getNumberOfBlocksFast(const char *blockname) const;
  537. S32 getNumberOfBlocks(const char *blockname) const;
  538. S32 getSizeFast(const char *blockname, const char *varname) const;
  539. S32 getSize(const char *blockname, const char *varname) const;
  540. S32 getSizeFast(const char *blockname, S32 blocknum, 
  541. const char *varname) const; // size in bytes of data
  542. S32 getSize(const char *blockname, S32 blocknum, const char *varname) const;
  543. void resetReceiveCounts(); // resets receive counts for all message types to 0
  544. void dumpReceiveCounts(); // dumps receive count for each message type to llinfos
  545. void dumpCircuitInfo(); // Circuit information to llinfos
  546. BOOL isClear() const; // returns mbSClear;
  547. S32  flush(const LLHost &host);
  548. U32 getListenPort( void ) const;
  549. void startLogging(); // start verbose  logging
  550. void stopLogging(); // flush and close file
  551. void summarizeLogs(std::ostream& str); // log statistics
  552. S32 getReceiveSize() const;
  553. S32 getReceiveCompressedSize() const { return mIncomingCompressedSize; }
  554. S32 getReceiveBytes() const;
  555. S32 getUnackedListSize() const { return mUnackedListSize; }
  556. //const char* getCurrentSMessageName() const { return mCurrentSMessageName; }
  557. //const char* getCurrentSBlockName() const { return mCurrentSBlockName; }
  558. // friends
  559. friend std::ostream& operator<<(std::ostream& s, LLMessageSystem &msg);
  560. void setMaxMessageTime(const F32 seconds); // Max time to process messages before warning and dumping (neg to disable)
  561. void setMaxMessageCounts(const S32 num); // Max number of messages before dumping (neg to disable)
  562. static U64 getMessageTimeUsecs(const BOOL update = FALSE); // Get the current message system time in microseconds
  563. static F64 getMessageTimeSeconds(const BOOL update = FALSE); // Get the current message system time in seconds
  564. static void setTimeDecodes(BOOL b);
  565. static void setTimeDecodesSpamThreshold(F32 seconds); 
  566. // message handlers internal to the message systesm
  567. //static void processAssignCircuitCode(LLMessageSystem* msg, void**);
  568. static void processAddCircuitCode(LLMessageSystem* msg, void**);
  569. static void processUseCircuitCode(LLMessageSystem* msg, void**);
  570. static void processError(LLMessageSystem* msg, void**);
  571. // dispatch llsd message to http node tree
  572. static void dispatch(const std::string& msg_name,
  573.  const LLSD& message);
  574. static void dispatch(const std::string& msg_name,
  575.  const LLSD& message,
  576.  LLHTTPNode::ResponsePtr responsep);
  577. // this is added to support specific legacy messages and is
  578. // ***not intended for general use*** Si, Gabriel, 2009
  579. static void dispatchTemplate(const std::string& msg_name,
  580.  const LLSD& message,
  581.  LLHTTPNode::ResponsePtr responsep);
  582. void setMessageBans(const LLSD& trusted, const LLSD& untrusted);
  583. /**
  584.  * @brief send an error message to the host. This is a helper method.
  585.  *
  586.  * @param host Destination host.
  587.  * @param agent_id Destination agent id (may be null)
  588.  * @param code An HTTP status compatible error code.
  589.  * @param token A specific short string based message
  590.  * @param id The transactionid/uniqueid/sessionid whatever.
  591.  * @param system The hierarchical path to the system (255 bytes)
  592.  * @param message Human readable message (1200 bytes) 
  593.  * @param data Extra info.
  594.  * @return Returns value returned from sendReliable().
  595.  */
  596. S32 sendError(
  597. const LLHost& host,
  598. const LLUUID& agent_id,
  599. S32 code,
  600. const std::string& token,
  601. const LLUUID& id,
  602. const std::string& system,
  603. const std::string& message,
  604. const LLSD& data);
  605. // Check UDP messages and pump http_pump to receive HTTP messages.
  606. bool checkAllMessages(S64 frame_count, LLPumpIO* http_pump);
  607. // Moved to allow access from LLTemplateMessageDispatcher
  608. void clearReceiveState();
  609. // This will cause all trust queries to return true until the next message
  610. // is read: use with caution!
  611. void receivedMessageFromTrustedSender();
  612. private:
  613. bool mLastMessageFromTrustedMessageService;
  614. // The mCircuitCodes is a map from circuit codes to session
  615. // ids. This allows us to verify sessions on connect.
  616. typedef std::map<U32, LLUUID> code_session_map_t;
  617. code_session_map_t mCircuitCodes;
  618. // Viewers need to track a process session in order to make sure
  619. // that no one gives them a bad circuit code.
  620. LLUUID mSessionID;
  621. void addTemplate(LLMessageTemplate *templatep);
  622. BOOL decodeTemplate( const U8* buffer, S32 buffer_size, LLMessageTemplate** msg_template );
  623. void logMsgFromInvalidCircuit( const LLHost& sender, BOOL recv_reliable );
  624. void logTrustedMsgFromUntrustedCircuit( const LLHost& sender );
  625. void logValidMsg(LLCircuitData *cdp, const LLHost& sender, BOOL recv_reliable, BOOL recv_resent, BOOL recv_acks );
  626. void logRanOffEndOfPacket( const LLHost& sender );
  627. class LLMessageCountInfo
  628. {
  629. public:
  630. U32 mMessageNum;
  631. U32 mMessageBytes;
  632. BOOL mInvalid;
  633. };
  634. LLMessagePollInfo *mPollInfop;
  635. U8 mEncodedRecvBuffer[MAX_BUFFER_SIZE];
  636. U8 mTrueReceiveBuffer[MAX_BUFFER_SIZE];
  637. S32 mTrueReceiveSize;
  638. // Must be valid during decode
  639. BOOL mbError;
  640. S32 mErrorCode;
  641. F64 mResendDumpTime; // The last time we dumped resends
  642. LLMessageCountInfo mMessageCountList[MAX_MESSAGE_COUNT_NUM];
  643. S32 mNumMessageCounts;
  644. F32 mReceiveTime;
  645. F32 mMaxMessageTime; // Max number of seconds for processing messages
  646. S32 mMaxMessageCounts; // Max number of messages to process before dumping.
  647. F64 mMessageCountTime;
  648. F64 mCurrentMessageTimeSeconds; // The current "message system time" (updated the first call to checkMessages after a resetReceiveCount
  649. // message system exceptions
  650. typedef std::pair<msg_exception_callback, void*> exception_t;
  651. typedef std::map<EMessageException, exception_t> callbacks_t;
  652. callbacks_t mExceptionCallbacks;
  653. // stuff for logging
  654. LLTimer mMessageSystemTimer;
  655. static F32 mTimeDecodesSpamThreshold;  // If mTimeDecodes is on, all this many seconds for each msg decode before spamming
  656. static BOOL mTimeDecodes;  // Measure time for all message decodes if TRUE;
  657. msg_timing_callback mTimingCallback;
  658. void* mTimingCallbackData;
  659. void init(); // ctor shared initialisation.
  660. LLHost mLastSender;
  661. LLHost mLastReceivingIF;
  662. S32 mIncomingCompressedSize; // original size of compressed msg (0 if uncomp.)
  663. TPACKETID mCurrentRecvPacketID;       // packet ID of current receive packet (for reporting)
  664. LLMessageBuilder* mMessageBuilder;
  665. LLTemplateMessageBuilder* mTemplateMessageBuilder;
  666. LLSDMessageBuilder* mLLSDMessageBuilder;
  667. LLMessageReader* mMessageReader;
  668. LLTemplateMessageReader* mTemplateMessageReader;
  669. LLSDMessageReader* mLLSDMessageReader;
  670. friend class LLMessageHandlerBridge;
  671. bool callHandler(const char *name, bool trustedSource,
  672.  LLMessageSystem* msg);
  673. /** Find, create or revive circuit for host as needed */
  674. LLCircuitData* findCircuit(const LLHost& host, bool resetPacketId);
  675. };
  676. // external hook into messaging system
  677. extern LLMessageSystem *gMessageSystem;
  678. // Must specific overall system version, which is used to determine
  679. // if a patch is available in the message template checksum verification.
  680. // Return true if able to initialize system.
  681. bool start_messaging_system(
  682. const std::string& template_name,
  683. U32 port, 
  684. S32 version_major,
  685. S32 version_minor,
  686. S32 version_patch,
  687. bool b_dump_prehash_file,
  688. const std::string& secret,
  689. const LLUseCircuitCodeResponder* responder,
  690. bool failure_is_fatal,
  691. const F32 circuit_heartbeat_interval, 
  692. const F32 circuit_timeout);
  693. void end_messaging_system(bool print_summary = true);
  694. void null_message_callback(LLMessageSystem *msg, void **data);
  695. //
  696. // Inlines
  697. //
  698. #if !defined( LL_BIG_ENDIAN ) && !defined( LL_LITTLE_ENDIAN )
  699. #error Unknown endianness for htonmemcpy. Did you miss a common include?
  700. #endif
  701. static inline void *htonmemcpy(void *vs, const void *vct, EMsgVariableType type, size_t n)
  702. {
  703. char *s = (char *)vs;
  704. const char *ct = (const char *)vct;
  705. #ifdef LL_BIG_ENDIAN
  706. S32 i, length;
  707. #endif
  708. switch(type)
  709. {
  710. case MVT_FIXED:
  711. case MVT_VARIABLE:
  712. case MVT_U8:
  713. case MVT_S8:
  714. case MVT_BOOL:
  715. case MVT_LLUUID:
  716. case MVT_IP_ADDR: // these two are swizzled in the getters and setters
  717. case MVT_IP_PORT: // these two are swizzled in the getters and setters
  718. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  719. case MVT_U16:
  720. case MVT_S16:
  721. if (n != 2)
  722. {
  723. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  724. }
  725. #ifdef LL_BIG_ENDIAN
  726. *(s + 1) = *(ct);
  727. *(s) = *(ct + 1);
  728. return(vs);
  729. #else
  730. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  731. #endif
  732. case MVT_U32:
  733. case MVT_S32:
  734. case MVT_F32:
  735. if (n != 4)
  736. {
  737. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  738. }
  739. #ifdef LL_BIG_ENDIAN
  740. *(s + 3) = *(ct);
  741. *(s + 2) = *(ct + 1);
  742. *(s + 1) = *(ct + 2);
  743. *(s) = *(ct + 3);
  744. return(vs);
  745. #else
  746. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  747. #endif
  748. case MVT_U64:
  749. case MVT_S64:
  750. case MVT_F64:
  751. if (n != 8)
  752. {
  753. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  754. }
  755. #ifdef LL_BIG_ENDIAN
  756. *(s + 7) = *(ct);
  757. *(s + 6) = *(ct + 1);
  758. *(s + 5) = *(ct + 2);
  759. *(s + 4) = *(ct + 3);
  760. *(s + 3) = *(ct + 4);
  761. *(s + 2) = *(ct + 5);
  762. *(s + 1) = *(ct + 6);
  763. *(s) = *(ct + 7);
  764. return(vs);
  765. #else
  766. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  767. #endif
  768. case MVT_LLVector3:
  769. case MVT_LLQuaternion:  // We only send x, y, z and infer w (we set x, y, z to ensure that w >= 0)
  770. if (n != 12)
  771. {
  772. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  773. }
  774. #ifdef LL_BIG_ENDIAN
  775. htonmemcpy(s + 8, ct + 8, MVT_F32, 4);
  776. htonmemcpy(s + 4, ct + 4, MVT_F32, 4);
  777. return(htonmemcpy(s, ct, MVT_F32, 4));
  778. #else
  779. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  780. #endif
  781. case MVT_LLVector3d:
  782. if (n != 24)
  783. {
  784. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  785. }
  786. #ifdef LL_BIG_ENDIAN
  787. htonmemcpy(s + 16, ct + 16, MVT_F64, 8);
  788. htonmemcpy(s + 8, ct + 8, MVT_F64, 8);
  789. return(htonmemcpy(s, ct, MVT_F64, 8));
  790. #else
  791. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  792. #endif
  793. case MVT_LLVector4:
  794. if (n != 16)
  795. {
  796. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  797. }
  798. #ifdef LL_BIG_ENDIAN
  799. htonmemcpy(s + 12, ct + 12, MVT_F32, 4);
  800. htonmemcpy(s + 8, ct + 8, MVT_F32, 4);
  801. htonmemcpy(s + 4, ct + 4, MVT_F32, 4);
  802. return(htonmemcpy(s, ct, MVT_F32, 4));
  803. #else
  804. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  805. #endif
  806. case MVT_U16Vec3:
  807. if (n != 6)
  808. {
  809. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  810. }
  811. #ifdef LL_BIG_ENDIAN
  812. htonmemcpy(s + 4, ct + 4, MVT_U16, 2);
  813. htonmemcpy(s + 2, ct + 2, MVT_U16, 2);
  814. return(htonmemcpy(s, ct, MVT_U16, 2));
  815. #else
  816. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  817. #endif
  818. case MVT_U16Quat:
  819. if (n != 8)
  820. {
  821. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  822. }
  823. #ifdef LL_BIG_ENDIAN
  824. htonmemcpy(s + 6, ct + 6, MVT_U16, 2);
  825. htonmemcpy(s + 4, ct + 4, MVT_U16, 2);
  826. htonmemcpy(s + 2, ct + 2, MVT_U16, 2);
  827. return(htonmemcpy(s, ct, MVT_U16, 2));
  828. #else
  829. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  830. #endif
  831. case MVT_S16Array:
  832. if (n % 2)
  833. {
  834. llerrs << "Size argument passed to htonmemcpy doesn't match swizzle type size" << llendl;
  835. }
  836. #ifdef LL_BIG_ENDIAN
  837. length = n % 2;
  838. for (i = 1; i < length; i++)
  839. {
  840. htonmemcpy(s + i*2, ct + i*2, MVT_S16, 2);
  841. }
  842. return(htonmemcpy(s, ct, MVT_S16, 2));
  843. #else
  844. return(memcpy(s,ct,n));
  845. #endif
  846. default:
  847. return(memcpy(s,ct,n)); /* Flawfinder: ignore */ 
  848. }
  849. }
  850. inline void *ntohmemcpy(void *s, const void *ct, EMsgVariableType type, size_t n)
  851. {
  852. return(htonmemcpy(s,ct,type, n));
  853. }
  854. inline const LLHost& LLMessageSystem::getReceivingInterface() const {return mLastReceivingIF;}
  855. inline U32 LLMessageSystem::getSenderIP() const 
  856. {
  857. return mLastSender.getAddress();
  858. }
  859. inline U32 LLMessageSystem::getSenderPort() const
  860. {
  861. return mLastSender.getPort();
  862. }
  863. //-----------------------------------------------------------------------------
  864. // Transmission aliases
  865. //-----------------------------------------------------------------------------
  866. inline S32 LLMessageSystem::sendMessage(const U32 circuit)
  867. {
  868. return sendMessage(findHost(circuit));
  869. }
  870. #endif