diff options
Diffstat (limited to 'indra/llmessage')
33 files changed, 2001 insertions, 2262 deletions
diff --git a/indra/llmessage/llcircuit.h b/indra/llmessage/llcircuit.h index a02c67e41d..ee8792ea4d 100644 --- a/indra/llmessage/llcircuit.h +++ b/indra/llmessage/llcircuit.h @@ -38,7 +38,11 @@ const F32 LL_AVERAGED_PING_MIN = 100; // msec // IW: increased to avoid ret const U32 INITIAL_PING_VALUE_MSEC = 1000; // initial value for the ping delay, or for ping delay for an unknown circuit const TPACKETID LL_MAX_OUT_PACKET_ID = 0x01000000; -const U8 LL_PACKET_ID_SIZE = 4; + +// 0 - flags +// [1,4] - packetid +// 5 - data offset (after message name) +const U8 LL_PACKET_ID_SIZE = 6; const S32 LL_MAX_RESENT_PACKETS_PER_FRAME = 100; const S32 LL_MAX_ACKED_PACKETS_PER_FRAME = 200; diff --git a/indra/llmessage/llhost.cpp b/indra/llmessage/llhost.cpp index 6a74cfe831..9fa98cf09c 100644 --- a/indra/llmessage/llhost.cpp +++ b/indra/llmessage/llhost.cpp @@ -210,9 +210,9 @@ std::ostream& operator<< (std::ostream& os, const LLHost &hh) } -std::istream& operator>> (std::istream& is, LLHost &rh) -{ - is >> rh.mIP; - is >> rh.mPort; - return is; -} +//std::istream& operator>> (std::istream& is, LLHost &rh) +//{ +// is >> rh.mIP; +// is >> rh.mPort; +// return is; +//} diff --git a/indra/llmessage/llhost.h b/indra/llmessage/llhost.h index 09dbae61b9..df1b6f31f7 100644 --- a/indra/llmessage/llhost.h +++ b/indra/llmessage/llhost.h @@ -83,7 +83,11 @@ public: std::string getIPandPort() const; friend std::ostream& operator<< (std::ostream& os, const LLHost &hh); - friend std::istream& operator>> (std::istream& is, LLHost &hh); + + // This operator is not well defined. does it expect a + // "192.168.1.1:80" notation or "int int" format? Phoenix 2007-05-18 + //friend std::istream& operator>> (std::istream& is, LLHost &hh); + friend bool operator==( const LLHost &lhs, const LLHost &rhs ); friend bool operator!=( const LLHost &lhs, const LLHost &rhs ); friend bool operator<(const LLHost &lhs, const LLHost &rhs); diff --git a/indra/llmessage/llhttpclient.cpp b/indra/llmessage/llhttpclient.cpp index 16586dc9c7..1bc6d742f1 100644 --- a/indra/llmessage/llhttpclient.cpp +++ b/indra/llmessage/llhttpclient.cpp @@ -23,12 +23,9 @@ #include <curl/curl.h> const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f; - static std::string gCABundle; - - LLHTTPClient::Responder::Responder() : mReferenceCount(0) { diff --git a/indra/llmessage/llhttpsender.cpp b/indra/llmessage/llhttpsender.cpp index 4152dedae5..b9fd8ecbf7 100644 --- a/indra/llmessage/llhttpsender.cpp +++ b/indra/llmessage/llhttpsender.cpp @@ -20,6 +20,7 @@ namespace { typedef std::map<LLHost, LLHTTPSender*> SenderMap; static SenderMap senderMap; + static LLHTTPSender* defaultSender = new LLHTTPSender(); } //virtual @@ -49,11 +50,10 @@ void LLHTTPSender::setSender(const LLHost& host, LLHTTPSender* sender) //static const LLHTTPSender& LLHTTPSender::getSender(const LLHost& host) { - static LLHTTPSender defaultSender; SenderMap::const_iterator iter = senderMap.find(host); if(iter == senderMap.end()) { - return defaultSender; + return *defaultSender; } return *(iter->second); } @@ -68,3 +68,10 @@ void LLHTTPSender::clearSender(const LLHost& host) senderMap.erase(iter); } } + +//static +void LLHTTPSender::setDefaultSender(LLHTTPSender* sender) +{ + delete defaultSender; + defaultSender = sender; +} diff --git a/indra/llmessage/llhttpsender.h b/indra/llmessage/llhttpsender.h index a9f42579c2..0ba8e30945 100644 --- a/indra/llmessage/llhttpsender.h +++ b/indra/llmessage/llhttpsender.h @@ -33,6 +33,9 @@ class LLHTTPSender /** @brief Clear sender for host. */ static void clearSender(const LLHost& host); + + /** @brief Set default sender, takes ownership of sender. */ + static void setDefaultSender(LLHTTPSender* sender); }; #endif // LL_HTTP_SENDER_H diff --git a/indra/llmessage/lliosocket.cpp b/indra/llmessage/lliosocket.cpp index e96b23f134..d1e4a8af31 100644 --- a/indra/llmessage/lliosocket.cpp +++ b/indra/llmessage/lliosocket.cpp @@ -401,6 +401,7 @@ LLIOPipe::EStatus LLIOSocketWriter::process_impl( PUMP_DEBUG; apr_size_t len; bool done = false; + apr_status_t status = APR_SUCCESS; while(it != end) { @@ -408,9 +409,8 @@ LLIOPipe::EStatus LLIOSocketWriter::process_impl( if((*it).isOnChannel(channels.in())) { PUMP_DEBUG; - // *FIX: check return code - sockets will fail (broken, etc.) len = (apr_size_t)segment.size(); - apr_status_t status = apr_socket_send( + status = apr_socket_send( mDestination->getSocket(), (const char*)segment.data(), &len); @@ -418,12 +418,12 @@ LLIOPipe::EStatus LLIOSocketWriter::process_impl( // completed immediately' error from apr_socket_send. In this // case we break and the data will be sent the next time the chain // is pumped. -#if LL_WINDOWS - if (status == 730035) + if(APR_STATUS_IS_EAGAIN(status)) + { + ll_apr_warn_status(status); break; -#else - (void) status; -#endif + } + mLastWritten = segment.data() + len - 1; PUMP_DEBUG; diff --git a/indra/llmessage/llmessagebuilder.h b/indra/llmessage/llmessagebuilder.h index 7ae09c54d5..7bbf7ebd56 100644 --- a/indra/llmessage/llmessagebuilder.h +++ b/indra/llmessage/llmessagebuilder.h @@ -1,3 +1,11 @@ +/** + * @file llmessagebuilder.h + * @brief Declaration of LLMessageBuilder class. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #ifndef LL_LLMESSAGEBUILDER_H #define LL_LLMESSAGEBUILDER_H @@ -20,31 +28,33 @@ public: //CLASS_LOG_TYPE(LLMessageBuilder); virtual ~LLMessageBuilder(); - virtual void newMessage(const char *name) = 0; + virtual void newMessage(const char* name) = 0; virtual void nextBlock(const char* blockname) = 0; virtual BOOL removeLastBlock() = 0; // TODO: babbage: remove this horror /** All add* methods expect pointers to canonical strings. */ - virtual void addBinaryData(const char *varname, const void *data, - S32 size) = 0; + virtual void addBinaryData( + const char* varname, + const void* data, + S32 size) = 0; virtual void addBOOL(const char* varname, BOOL b) = 0; - virtual void addS8(const char *varname, S8 s) = 0; - virtual void addU8(const char *varname, U8 u) = 0; - virtual void addS16(const char *varname, S16 i) = 0; - virtual void addU16(const char *varname, U16 i) = 0; - virtual void addF32(const char *varname, F32 f) = 0; - virtual void addS32(const char *varname, S32 s) = 0; - virtual void addU32(const char *varname, U32 u) = 0; - virtual void addU64(const char *varname, U64 lu) = 0; - virtual void addF64(const char *varname, F64 d) = 0; - virtual void addVector3(const char *varname, const LLVector3& vec) = 0; - virtual void addVector4(const char *varname, const LLVector4& vec) = 0; - virtual void addVector3d(const char *varname, const LLVector3d& vec) = 0; - virtual void addQuat(const char *varname, const LLQuaternion& quat) = 0; - virtual void addUUID(const char *varname, const LLUUID& uuid) = 0; - virtual void addIPAddr(const char *varname, const U32 ip) = 0; - virtual void addIPPort(const char *varname, const U16 port) = 0; + virtual void addS8(const char* varname, S8 s) = 0; + virtual void addU8(const char* varname, U8 u) = 0; + virtual void addS16(const char* varname, S16 i) = 0; + virtual void addU16(const char* varname, U16 i) = 0; + virtual void addF32(const char* varname, F32 f) = 0; + virtual void addS32(const char* varname, S32 s) = 0; + virtual void addU32(const char* varname, U32 u) = 0; + virtual void addU64(const char* varname, U64 lu) = 0; + virtual void addF64(const char* varname, F64 d) = 0; + virtual void addVector3(const char* varname, const LLVector3& vec) = 0; + virtual void addVector4(const char* varname, const LLVector4& vec) = 0; + virtual void addVector3d(const char* varname, const LLVector3d& vec) = 0; + virtual void addQuat(const char* varname, const LLQuaternion& quat) = 0; + virtual void addUUID(const char* varname, const LLUUID& uuid) = 0; + virtual void addIPAddr(const char* varname, const U32 ip) = 0; + virtual void addIPPort(const char* varname, const U16 port) = 0; virtual void addString(const char* varname, const char* s) = 0; virtual void addString(const char* varname, const std::string& s) = 0; @@ -54,7 +64,10 @@ public: virtual BOOL isBuilt() const = 0; virtual BOOL isClear() const = 0; - virtual U32 buildMessage(U8* buffer, U32 buffer_size) = 0; + virtual U32 buildMessage( + U8* buffer, + U32 buffer_size, + U8 offset_to_data) = 0; /**< Return built message size */ virtual void clearMessage() = 0; diff --git a/indra/llmessage/llmessageconfig.cpp b/indra/llmessage/llmessageconfig.cpp index 3cc17d67df..dd2d725d32 100644 --- a/indra/llmessage/llmessageconfig.cpp +++ b/indra/llmessage/llmessageconfig.cpp @@ -12,37 +12,44 @@ #include "llfile.h" #include "lllivefile.h" #include "llsd.h" +#include "llsdutil.h" #include "llsdserialize.h" +#include "message.h" static const char messageConfigFileName[] = "message.xml"; static const F32 messageConfigRefreshRate = 5.0; // seconds + static std::string sServerName = ""; static std::string sConfigDir = ""; +static std::string sServerDefault; +static LLSD sMessages; + + class LLMessageConfigFile : public LLLiveFile { -private: +public: LLMessageConfigFile() - : LLLiveFile(fileName(), messageConfigRefreshRate), - mChanged(false) + : LLLiveFile(fileName(), messageConfigRefreshRate) { } static std::string fileName(); - -public: + + LLSD mMessages; + std::string mServerDefault; + static LLMessageConfigFile& instance(); // return the singleton configuration file -protected: /* virtual */ void loadFile(); void loadServerDefaults(const LLSD& data); void loadMessages(const LLSD& data); + void loadCapBans(const LLSD& blacklist); + void loadMessageBans(const LLSD& blacklist); + bool isCapBanned(const std::string& cap_name) const; public: - bool mChanged; - - std::string mServerDefault; - LLSD mMessages; + LLSD mCapBans; }; std::string LLMessageConfigFile::fileName() @@ -82,26 +89,63 @@ void LLMessageConfigFile::loadFile() } loadServerDefaults(data); loadMessages(data); + loadCapBans(data); + loadMessageBans(data); } void LLMessageConfigFile::loadServerDefaults(const LLSD& data) { mServerDefault = data["serverDefaults"][sServerName].asString(); - lldebugs << "loading default " << mServerDefault << llendl; } void LLMessageConfigFile::loadMessages(const LLSD& data) { - LLPointer<LLSDXMLFormatter> formatter = new LLSDXMLFormatter; - std::ostringstream out; - mMessages = data["messages"]; + +#ifdef DEBUG + std::ostringstream out; + LLSDXMLFormatter *formatter = new LLSDXMLFormatter; formatter->format(mMessages, out); - lldebugs << "loading ... " << out.str() + llinfos << "loading ... " << out.str() << " LLMessageConfigFile::loadMessages loaded " << mMessages.size() << " messages" << llendl; +#endif } +void LLMessageConfigFile::loadCapBans(const LLSD& data) +{ + LLSD bans = data["capBans"]; + if (!bans.isMap()) + { + llinfos << "LLMessageConfigFile::loadCapBans: missing capBans section" + << llendl; + return; + } + + mCapBans = bans; + + llinfos << "LLMessageConfigFile::loadCapBans: " + << bans.size() << " ban tests" << llendl; +} + +void LLMessageConfigFile::loadMessageBans(const LLSD& data) +{ + LLSD bans = data["messageBans"]; + if (!bans.isMap()) + { + llinfos << "LLMessageConfigFile::loadMessageBans: missing messageBans section" + << llendl; + return; + } + + gMessageSystem->setMessageBans(bans["trusted"], bans["untrusted"]); +} + +bool LLMessageConfigFile::isCapBanned(const std::string& cap_name) const +{ + llinfos << "mCapBans is " << LLSDXMLStreamer(mCapBans) << llendl; + return mCapBans[cap_name]; +} //--------------------------------------------------------------- // LLMessageConfig @@ -114,98 +158,77 @@ void LLMessageConfig::initClass(const std::string& server_name, sServerName = server_name; sConfigDir = config_dir; (void) LLMessageConfigFile::instance(); - llinfos << "LLMessageConfig::intiClass config file " + llinfos << "LLMessageConfig::initClass config file " << config_dir << "/" << messageConfigFileName << llendl; } //static -bool LLMessageConfig::isServerDefaultBuilderLLSD() +void LLMessageConfig::useConfig(const LLSD& config) { - if (sServerName.empty()) - { - llerrs << "LLMessageConfig::isServerDefaultBuilderLLSD() before" - << " LLMessageConfig::initClass()" << llendl; - } - LLMessageConfigFile& file = LLMessageConfigFile::instance(); - return (file.mServerDefault == "llsd"); -} + LLMessageConfigFile &the_file = LLMessageConfigFile::instance(); + the_file.loadServerDefaults(config); + the_file.loadMessages(config); + the_file.loadCapBans(config); + the_file.loadMessageBans(config); -//static -bool LLMessageConfig::isServerDefaultBuilderTemplate() -{ - if (sServerName.empty()) - { - llerrs << "LLMessageConfig::isServerDefaultBuilderTemplate() before" - << " LLMessageConfig::initClass()" << llendl; - } - LLMessageConfigFile& file = LLMessageConfigFile::instance(); - return (file.mServerDefault == "template"); } //static -bool LLMessageConfig::isMessageBuiltLLSD(const std::string& msg_name) +LLMessageConfig::Flavor LLMessageConfig::getServerDefaultFlavor() { - if (sServerName.empty()) + LLMessageConfigFile& file = LLMessageConfigFile::instance(); + if (file.mServerDefault == "llsd") { - llerrs << "LLMessageConfig::isMessageBuiltLLSD(name) before" - << " LLMessageConfig::initClass()" << llendl; + return LLSD_FLAVOR; } - LLMessageConfigFile& file = LLMessageConfigFile::instance(); - LLSD config = file.mMessages[msg_name]; - if (!config.has("builder")) + if (file.mServerDefault == "template") { - return isServerDefaultBuilderLLSD(); + return TEMPLATE_FLAVOR; } - return (config["builder"].asString() == "llsd"); + return NO_FLAVOR; } //static -bool LLMessageConfig::isMessageBuiltTemplate(const std::string& msg_name) +LLMessageConfig::Flavor LLMessageConfig::getMessageFlavor(const std::string& msg_name) { - if (sServerName.empty()) - { - llerrs << "LLMessageConfig::isMessageBuiltTemplate(name) before" - << " LLMessageConfig::initClass()" << llendl; - } LLMessageConfigFile& file = LLMessageConfigFile::instance(); LLSD config = file.mMessages[msg_name]; - if (!config.has("builder")) + if (config["flavor"].asString() == "llsd") { - return isServerDefaultBuilderTemplate(); + return LLSD_FLAVOR; } - return (config["builder"].asString() == "template"); + if (config["flavor"].asString() == "template") + { + return TEMPLATE_FLAVOR; + } + return NO_FLAVOR; } //static -bool LLMessageConfig::isMessageTrusted(const std::string& msg_name) +LLMessageConfig::SenderTrust LLMessageConfig::getSenderTrustedness( + const std::string& msg_name) { - if (sServerName.empty()) - { - llerrs << "LLMessageConfig::isMessageTrusted(name) before" - << " LLMessageConfig::initClass()" << llendl; - } LLMessageConfigFile& file = LLMessageConfigFile::instance(); LLSD config = file.mMessages[msg_name]; - if (!config.has("trusted-sender")) + if (config.has("trusted-sender")) { - return false; + return config["trusted-sender"].asBoolean() ? TRUSTED : UNTRUSTED; } - return config["trusted-sender"].asBoolean(); + return NOT_SET; } //static -bool LLMessageConfig::isValidUntrustedMessage(const std::string& msg_name) +bool LLMessageConfig::isValidMessage(const std::string& msg_name) { if (sServerName.empty()) { - llerrs << "LLMessageConfig::isMessageTrusted(name) before" - << " LLMessageConfig::initClass()" << llendl; + llerrs << "LLMessageConfig::initClass() not called" << llendl; } LLMessageConfigFile& file = LLMessageConfigFile::instance(); - LLSD config = file.mMessages[msg_name]; - if (!config.has("trusted-sender")) - { - return false; - } - return !(config["trusted-sender"].asBoolean()); + return file.mMessages.has(msg_name); +} + +bool LLMessageConfig::isCapBanned(const std::string& cap_name) +{ + return LLMessageConfigFile::instance().isCapBanned(cap_name); } diff --git a/indra/llmessage/llmessageconfig.h b/indra/llmessage/llmessageconfig.h index 2fb6f2077e..a99cdc46fa 100644 --- a/indra/llmessage/llmessageconfig.h +++ b/indra/llmessage/llmessageconfig.h @@ -11,21 +11,24 @@ #include <string> +class LLSD; + class LLMessageConfig { public: + enum Flavor { NO_FLAVOR=0, LLSD_FLAVOR=1, TEMPLATE_FLAVOR=2 }; + enum SenderTrust { NOT_SET=0, UNTRUSTED=1, TRUSTED=2 }; + static void initClass(const std::string& server_name, const std::string& config_dir); - // force loading of config file during startup process - // so it can be used for startup features + static void useConfig(const LLSD& config); - static bool isServerDefaultBuilderLLSD(); - static bool isServerDefaultBuilderTemplate(); + static Flavor getServerDefaultFlavor(); // For individual messages - static bool isMessageBuiltLLSD(const std::string& msg_name); - static bool isMessageBuiltTemplate(const std::string& msg_name); - static bool isMessageTrusted(const std::string& msg_name); - static bool isValidUntrustedMessage(const std::string& msg_name); + static Flavor getMessageFlavor(const std::string& msg_name); + static SenderTrust getSenderTrustedness(const std::string& msg_name); + static bool isValidMessage(const std::string& msg_name); + static bool isCapBanned(const std::string& cap_name); }; #endif // LL_MESSAGECONFIG_H diff --git a/indra/llmessage/llmessagereader.cpp b/indra/llmessage/llmessagereader.cpp index 4824480e32..5375fab0f8 100644 --- a/indra/llmessage/llmessagereader.cpp +++ b/indra/llmessage/llmessagereader.cpp @@ -1,3 +1,11 @@ +/** + * @file llmessagereader.cpp + * @brief LLMessageReader class implementation + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #include "llmessagereader.h" static BOOL sTimeDecodes = FALSE; diff --git a/indra/llmessage/llmessagereader.h b/indra/llmessage/llmessagereader.h index 33ce9289f5..65a7032754 100644 --- a/indra/llmessage/llmessagereader.h +++ b/indra/llmessage/llmessagereader.h @@ -1,3 +1,11 @@ +/** + * @file llmessagereader.h + * @brief Declaration of LLMessageReader class. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #ifndef LL_LLMESSAGEREADER_H #define LL_LLMESSAGEREADER_H @@ -45,6 +53,7 @@ class LLMessageReader virtual void clearMessage() = 0; + /** Returns pointer to canonical (prehashed) string. */ virtual const char* getMessageName() const = 0; virtual S32 getMessageSize() const = 0; diff --git a/indra/llmessage/llmessagetemplate.cpp b/indra/llmessage/llmessagetemplate.cpp index 026843d6ec..7383308ddd 100644 --- a/indra/llmessage/llmessagetemplate.cpp +++ b/indra/llmessage/llmessagetemplate.cpp @@ -1,3 +1,11 @@ +/** + * @file llmessagetemplate.cpp + * @brief Implementation of message template classes. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #include "linden_common.h" #include "llmessagetemplate.h" @@ -94,7 +102,7 @@ std::ostream& operator<<(std::ostream& s, LLMessageBlock &msg) for (LLMessageBlock::message_variable_map_t::iterator iter = msg.mMemberVariables.begin(); iter != msg.mMemberVariables.end(); iter++) { - LLMessageVariable& ci = *(iter->second); + LLMessageVariable& ci = *(*iter); s << ci; } @@ -138,7 +146,7 @@ std::ostream& operator<<(std::ostream& s, LLMessageTemplate &msg) for (LLMessageTemplate::message_block_map_t::iterator iter = msg.mMemberBlocks.begin(); iter != msg.mMemberBlocks.end(); iter++) { - LLMessageBlock* ci = iter->second; + LLMessageBlock* ci = *iter; s << *ci; } diff --git a/indra/llmessage/llmessagetemplate.h b/indra/llmessage/llmessagetemplate.h index 8847ddc0d9..b7a661fa1a 100644 --- a/indra/llmessage/llmessagetemplate.h +++ b/indra/llmessage/llmessagetemplate.h @@ -1,3 +1,11 @@ +/** + * @file llmessagetemplate.h + * @brief Declaration of the message template classes. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #ifndef LL_LLMESSAGETEMPLATE_H #define LL_LLMESSAGETEMPLATE_H @@ -123,7 +131,7 @@ public: mName = name; } - LLMessageVariable(char *name, const EMsgVariableType type, const S32 size) : mType(type), mSize(size) + LLMessageVariable(const char *name, const EMsgVariableType type, const S32 size) : mType(type), mSize(size) { mName = gMessageStringTable.getString(name); } @@ -154,14 +162,14 @@ typedef enum e_message_block_type class LLMessageBlock { public: - LLMessageBlock(char *name, EMsgBlockType type, S32 number = 1) : mType(type), mNumber(number), mTotalSize(0) + LLMessageBlock(const char *name, EMsgBlockType type, S32 number = 1) : mType(type), mNumber(number), mTotalSize(0) { mName = gMessageStringTable.getString(name); } ~LLMessageBlock() { - for_each(mMemberVariables.begin(), mMemberVariables.end(), DeletePairedPointer()); + for_each(mMemberVariables.begin(), mMemberVariables.end(), DeletePointer()); } void addVariable(char *name, const EMsgVariableType type, const S32 size) @@ -193,9 +201,15 @@ public: return (mMemberVariables[name])->getSize(); } + const LLMessageVariable* getVariable(char* name) const + { + message_variable_map_t::const_iterator iter = mMemberVariables.find(name); + return iter != mMemberVariables.end()? *iter : NULL; + } + friend std::ostream& operator<<(std::ostream& s, LLMessageBlock &msg); - typedef std::map<const char *, LLMessageVariable*> message_variable_map_t; + typedef LLDynamicArrayIndexed<LLMessageVariable*, const char *, 8> message_variable_map_t; message_variable_map_t mMemberVariables; char *mName; EMsgBlockType mType; @@ -224,6 +238,13 @@ enum EMsgEncoding ME_ZEROCODED }; +enum EMsgDeprecation +{ + MD_NOTDEPRECATED, + MD_UDPDEPRECATED, + MD_DEPRECATED +}; + class LLMessageTemplate { public: @@ -234,7 +255,8 @@ public: mFrequency(freq), mTrust(MT_NOTRUST), mEncoding(ME_ZEROCODED), - mMessageNumber(message_number), + mDeprecation(MD_NOTDEPRECATED), + mMessageNumber(message_number), mTotalSize(0), mReceiveCount(0), mReceiveBytes(0), @@ -253,8 +275,8 @@ public: ~LLMessageTemplate() { - for_each(mMemberBlocks.begin(), mMemberBlocks.end(), DeletePairedPointer()); - } + for_each(mMemberBlocks.begin(), mMemberBlocks.end(), DeletePointer()); +} void addBlock(LLMessageBlock *blockp) { @@ -289,7 +311,7 @@ public: mTrust = t; } - EMsgTrust getTrust(void) + EMsgTrust getTrust(void) const { return mTrust; } @@ -299,18 +321,28 @@ public: { mEncoding = e; } - EMsgEncoding getEncoding() + EMsgEncoding getEncoding() const { return mEncoding; } + void setDeprecation(EMsgDeprecation d) + { + mDeprecation = d; + } + + EMsgDeprecation getDeprecation() const + { + return mDeprecation; + } + void setHandlerFunc(void (*handler_func)(LLMessageSystem *msgsystem, void **user_data), void **user_data) { mHandlerFunc = handler_func; mUserData = user_data; } - BOOL callHandlerFunc(LLMessageSystem *msgsystem) + BOOL callHandlerFunc(LLMessageSystem *msgsystem) const { if (mHandlerFunc) { @@ -320,20 +352,27 @@ public: return FALSE; } - bool isBanned(bool trustedSource) + bool isBanned(bool trustedSource) const { return trustedSource ? mBanFromTrusted : mBanFromUntrusted; } friend std::ostream& operator<<(std::ostream& s, LLMessageTemplate &msg); + const LLMessageBlock* getBlock(char* name) const + { + message_block_map_t::const_iterator iter = mMemberBlocks.find(name); + return iter != mMemberBlocks.end()? *iter : NULL; + } + public: - typedef std::map<char*, LLMessageBlock*> message_block_map_t; + typedef LLDynamicArrayIndexed<LLMessageBlock*, char*, 8> message_block_map_t; message_block_map_t mMemberBlocks; char *mName; EMsgFrequency mFrequency; EMsgTrust mTrust; EMsgEncoding mEncoding; + EMsgDeprecation mDeprecation; U32 mMessageNumber; S32 mTotalSize; U32 mReceiveCount; // how many of this template have been received since last reset diff --git a/indra/llmessage/llmessagetemplateparser.cpp b/indra/llmessage/llmessagetemplateparser.cpp new file mode 100644 index 0000000000..9c6dd8c73a --- /dev/null +++ b/indra/llmessage/llmessagetemplateparser.cpp @@ -0,0 +1,734 @@ +/** + * @file llmessagetemplateparser.cpp + * @brief LLMessageTemplateParser implementation + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + +#include "llmessagetemplateparser.h" +#include <boost/tokenizer.hpp> + + +// What follows is a bunch of C functions to do validation. + +// Lets support a small subset of regular expressions here +// Syntax is a string made up of: +// a - checks against alphanumeric ([A-Za-z0-9]) +// c - checks against character ([A-Za-z]) +// f - checks against first variable character ([A-Za-z_]) +// v - checks against variable ([A-Za-z0-9_]) +// s - checks against sign of integer ([-0-9]) +// d - checks against integer digit ([0-9]) +// * - repeat last check + +// checks 'a' +BOOL b_return_alphanumeric_ok(char c) +{ + if ( ( (c < 'A') + ||(c > 'Z')) + &&( (c < 'a') + ||(c > 'z')) + &&( (c < '0') + ||(c > '9'))) + { + return FALSE; + } + return TRUE; +} + +// checks 'c' +BOOL b_return_character_ok(char c) +{ + if ( ( (c < 'A') + ||(c > 'Z')) + &&( (c < 'a') + ||(c > 'z'))) + { + return FALSE; + } + return TRUE; +} + +// checks 'f' +BOOL b_return_first_variable_ok(char c) +{ + if ( ( (c < 'A') + ||(c > 'Z')) + &&( (c < 'a') + ||(c > 'z')) + &&(c != '_')) + { + return FALSE; + } + return TRUE; +} + +// checks 'v' +BOOL b_return_variable_ok(char c) +{ + if ( ( (c < 'A') + ||(c > 'Z')) + &&( (c < 'a') + ||(c > 'z')) + &&( (c < '0') + ||(c > '9')) + &&(c != '_')) + { + return FALSE; + } + return TRUE; +} + +// checks 's' +BOOL b_return_signed_integer_ok(char c) +{ + if ( ( (c < '0') + ||(c > '9')) + &&(c != '-')) + { + return FALSE; + } + return TRUE; +} + +// checks 'd' +BOOL b_return_integer_ok(char c) +{ + if ( (c < '0') + ||(c > '9')) + { + return FALSE; + } + return TRUE; +} + +BOOL (*gParseCheckCharacters[])(char c) = +{ + b_return_alphanumeric_ok, + b_return_character_ok, + b_return_first_variable_ok, + b_return_variable_ok, + b_return_signed_integer_ok, + b_return_integer_ok +}; + +S32 get_checker_number(char checker) +{ + switch(checker) + { + case 'a': + return 0; + case 'c': + return 1; + case 'f': + return 2; + case 'v': + return 3; + case 's': + return 4; + case 'd': + return 5; + case '*': + return 9999; + default: + return -1; + } +} + +// check token based on passed simplified regular expression +BOOL b_check_token(const char *token, char *regexp) +{ + S32 tptr, rptr = 0; + S32 current_checker, next_checker = 0; + + current_checker = get_checker_number(regexp[rptr++]); + + if (current_checker == -1) + { + llerrs << "Invalid regular expression value!" << llendl; + return FALSE; + } + + if (current_checker == 9999) + { + llerrs << "Regular expression can't start with *!" << llendl; + return FALSE; + } + + for (tptr = 0; token[tptr]; tptr++) + { + if (current_checker == -1) + { + llerrs << "Input exceeds regular expression!\nDid you forget a *?" << llendl; + return FALSE; + } + + if (!gParseCheckCharacters[current_checker](token[tptr])) + { + return FALSE; + } + if (next_checker != 9999) + { + next_checker = get_checker_number(regexp[rptr++]); + if (next_checker != 9999) + { + current_checker = next_checker; + } + } + } + return TRUE; +} + +// C variable can be made up of upper or lower case letters, underscores, or numbers, but can't start with a number +BOOL b_variable_ok(const char *token) +{ + if (!b_check_token(token, "fv*")) + { + llwarns << "Token '" << token << "' isn't a variable!" << llendl; + return FALSE; + } + return TRUE; +} + +// An integer is made up of the digits 0-9 and may be preceded by a '-' +BOOL b_integer_ok(const char *token) +{ + if (!b_check_token(token, "sd*")) + { + llwarns << "Token isn't an integer!" << llendl; + return FALSE; + } + return TRUE; +} + +// An integer is made up of the digits 0-9 +BOOL b_positive_integer_ok(const char *token) +{ + if (!b_check_token(token, "d*")) + { + llwarns << "Token isn't an integer!" << llendl; + return FALSE; + } + return TRUE; +} + + +// Done with C functions, here's the tokenizer. + +typedef boost::tokenizer< boost::char_separator<char> > tokenizer; + +LLTemplateTokenizer::LLTemplateTokenizer(const std::string & contents) : mStarted(false), mTokens() +{ + boost::char_separator<char> newline("\r\n", "", boost::keep_empty_tokens); + boost::char_separator<char> spaces(" \t"); + U32 line_counter = 1; + + tokenizer line_tokens(contents, newline); + for(tokenizer::iterator line_iter = line_tokens.begin(); + line_iter != line_tokens.end(); + ++line_iter, ++line_counter) + { + tokenizer word_tokens(*line_iter, spaces); + for(tokenizer::iterator word_iter = word_tokens.begin(); + word_iter != word_tokens.end(); + ++word_iter) + { + if((*word_iter)[0] == '/') + { + break; // skip to end of line on comments + } + positioned_token pt;// = new positioned_token(); + pt.str = std::string(*word_iter); + pt.line = line_counter; + mTokens.push_back(pt); + } + } + mCurrent = mTokens.begin(); +} +void LLTemplateTokenizer::inc() +{ + if(atEOF()) + { + error("trying to increment token of EOF"); + } + else if(mStarted) + { + ++mCurrent; + } + else + { + mStarted = true; + mCurrent = mTokens.begin(); + } +} +void LLTemplateTokenizer::dec() +{ + if(mCurrent == mTokens.begin()) + { + if(mStarted) + { + mStarted = false; + } + else + { + error("trying to decrement past beginning of file"); + } + } + else + { + mCurrent--; + } +} + +std::string LLTemplateTokenizer::get() const +{ + if(atEOF()) + { + error("trying to get EOF"); + } + return mCurrent->str; +} + +U32 LLTemplateTokenizer::line() const +{ + if(atEOF()) + { + return 0; + } + return mCurrent->line; +} + +bool LLTemplateTokenizer::atEOF() const +{ + return mCurrent == mTokens.end(); +} + +std::string LLTemplateTokenizer::next() +{ + inc(); + return get(); +} + +bool LLTemplateTokenizer::want(const std::string & token) +{ + if(atEOF()) return false; + inc(); + if(atEOF()) return false; + if(get() != token) + { + dec(); // back up a step + return false; + } + return true; +} + +bool LLTemplateTokenizer::wantEOF() +{ + // see if the next token is EOF + if(atEOF()) return true; + inc(); + if(!atEOF()) + { + dec(); // back up a step + return false; + } + return true; +} + +void LLTemplateTokenizer::error(std::string message) const +{ + if(atEOF()) + { + llerrs << "Unexpected end of file: " << message << llendl; + } + else + { + llerrs << "Problem parsing message template at line " + << line() << ", with token '" << get() << "' : " + << message << llendl; + } +} + + +// Done with tokenizer, next is the parser. + +LLTemplateParser::LLTemplateParser(LLTemplateTokenizer & tokens): + mVersion(0.f), + mMessages() +{ + // the version number should be the first thing in the file + if (tokens.want("version")) + { + // version number + std::string vers_string = tokens.next(); + mVersion = (F32)atof(vers_string.c_str()); + + llinfos << "### Message template version " << mVersion << " ###" << llendl; + } + else + { + llerrs << "Version must be first in the message template, found " + << tokens.next() << llendl; + } + + while(LLMessageTemplate * templatep = parseMessage(tokens)) + { + if (templatep->getDeprecation() != MD_DEPRECATED) + { + mMessages.push_back(templatep); + } + } + + if(!tokens.wantEOF()) + { + llerrs << "Expected end of template or a message, instead found: " + << tokens.next() << " at " << tokens.line() << llendl; + } +} + +F32 LLTemplateParser::getVersion() const +{ + return mVersion; +} + +LLTemplateParser::message_iterator LLTemplateParser::getMessagesBegin() const +{ + return mMessages.begin(); +} + +LLTemplateParser::message_iterator LLTemplateParser::getMessagesEnd() const +{ + return mMessages.end(); +} + + +// static +LLMessageTemplate * LLTemplateParser::parseMessage(LLTemplateTokenizer & tokens) +{ + LLMessageTemplate *templatep = NULL; + if(!tokens.want("{")) + { + return NULL; + } + + // name first + std::string template_name = tokens.next(); + + // is name a legit C variable name + if (!b_variable_ok(template_name.c_str())) + { + llerrs << "Not legit variable name: " << template_name << " at " << tokens.line() << llendl; + } + + // ok, now get Frequency ("High", "Medium", or "Low") + EMsgFrequency frequency = MFT_LOW; + std::string freq_string = tokens.next(); + if (freq_string == "High") + { + frequency = MFT_HIGH; + } + else if (freq_string == "Medium") + { + frequency = MFT_MEDIUM; + } + else if (freq_string == "Low" || freq_string == "Fixed") + { + frequency = MFT_LOW; + } + else + { + llerrs << "Expected frequency, got " << freq_string << " at " << tokens.line() << llendl; + } + + // TODO more explicit checking here pls + U32 message_number = strtoul(tokens.next().c_str(),NULL,0); + + switch (frequency) { + case MFT_HIGH: + break; + case MFT_MEDIUM: + message_number = (255 << 8) | message_number; + break; + case MFT_LOW: + message_number = (255 << 24) | (255 << 16) | message_number; + break; + default: + llerrs << "Unknown frequency enum: " << frequency << llendl; + } + + templatep = new LLMessageTemplate( + template_name.c_str(), + message_number, + frequency); + + // Now get trust ("Trusted", "NotTrusted") + std::string trust = tokens.next(); + if (trust == "Trusted") + { + templatep->setTrust(MT_TRUST); + } + else if (trust == "NotTrusted") + { + templatep->setTrust(MT_NOTRUST); + } + else + { + llerrs << "Bad trust " << trust << " at " << tokens.line() << llendl; + } + + // get encoding + std::string encoding = tokens.next(); + if(encoding == "Unencoded") + { + templatep->setEncoding(ME_UNENCODED); + } + else if(encoding == "Zerocoded") + { + templatep->setEncoding(ME_ZEROCODED); + } + else + { + llerrs << "Bad encoding " << encoding << " at " << tokens.line() << llendl; + } + + // get deprecation + if(tokens.want("Deprecated")) + { + templatep->setDeprecation(MD_DEPRECATED); + } + else if (tokens.want("UDPDeprecated")) + { + templatep->setDeprecation(MD_UDPDEPRECATED); + } + else if (tokens.want("NotDeprecated")) + { + // this is the default value, but it can't hurt to set it twice + templatep->setDeprecation(MD_NOTDEPRECATED); + } + else { + // It's probably a brace, let's just start block processing + } + + while(LLMessageBlock * blockp = parseBlock(tokens)) + { + templatep->addBlock(blockp); + } + + if(!tokens.want("}")) + { + llerrs << "Expecting closing } for message " << template_name + << " at " << tokens.line() << llendl; + } + return templatep; +} + +// static +LLMessageBlock * LLTemplateParser::parseBlock(LLTemplateTokenizer & tokens) +{ + LLMessageBlock * blockp = NULL; + + if(!tokens.want("{")) + { + return NULL; + } + + // name first + std::string block_name = tokens.next(); + + // is name a legit C variable name + if (!b_variable_ok(block_name.c_str())) + { + llerrs << "not a legal block name: " << block_name + << " at " << tokens.line() << llendl; + } + + // now, block type ("Single", "Multiple", or "Variable") + std::string block_type = tokens.next(); + // which one is it? + if (block_type == "Single") + { + // ok, we can create a block + blockp = new LLMessageBlock(block_name.c_str(), MBT_SINGLE); + } + else if (block_type == "Multiple") + { + // need to get the number of repeats + std::string repeats = tokens.next(); + + // is it a legal integer + if (!b_positive_integer_ok(repeats.c_str())) + { + llerrs << "not a legal integer for block multiple count: " + << repeats << " at " << tokens.line() << llendl; + } + + // ok, we can create a block + blockp = new LLMessageBlock(block_name.c_str(), + MBT_MULTIPLE, + atoi(repeats.c_str())); + } + else if (block_type == "Variable") + { + // ok, we can create a block + blockp = new LLMessageBlock(block_name.c_str(), MBT_VARIABLE); + } + else + { + llerrs << "bad block type: " << block_type + << " at " << tokens.line() << llendl; + } + + + while(LLMessageVariable * varp = parseVariable(tokens)) + { + blockp->addVariable(varp->getName(), + varp->getType(), + varp->getSize()); + delete varp; + } + + if(!tokens.want("}")) + { + llerrs << "Expecting closing } for block " << block_name + << " at " << tokens.line() << llendl; + } + return blockp; + +} + +// static +LLMessageVariable * LLTemplateParser::parseVariable(LLTemplateTokenizer & tokens) +{ + LLMessageVariable * varp = NULL; + if(!tokens.want("{")) + { + return NULL; + } + + std::string var_name = tokens.next(); + + if (!b_variable_ok(var_name.c_str())) + { + llerrs << "Not a legit variable name: " << var_name + << " at " << tokens.line() << llendl; + } + + std::string var_type = tokens.next(); + + if (var_type == "U8") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_U8, 1); + } + else if (var_type == "U16") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_U16, 2); + } + else if (var_type == "U32") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_U32, 4); + } + else if (var_type == "U64") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_U64, 8); + } + else if (var_type == "S8") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_S8, 1); + } + else if (var_type == "S16") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_S16, 2); + } + else if (var_type == "S32") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_S32, 4); + } + else if (var_type == "S64") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_S64, 8); + } + else if (var_type == "F32") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_F32, 4); + } + else if (var_type == "F64") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_F64, 8); + } + else if (var_type == "LLVector3") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_LLVector3, 12); + } + else if (var_type == "LLVector3d") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_LLVector3d, 24); + } + else if (var_type == "LLVector4") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_LLVector4, 16); + } + else if (var_type == "LLQuaternion") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_LLQuaternion, 12); + } + else if (var_type == "LLUUID") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_LLUUID, 16); + } + else if (var_type == "BOOL") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_BOOL, 1); + } + else if (var_type == "IPADDR") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_IP_ADDR, 4); + } + else if (var_type == "IPPORT") + { + varp = new LLMessageVariable(var_name.c_str(), MVT_IP_PORT, 2); + } + else if (var_type == "Fixed" || var_type == "Variable") + { + std::string variable_size = tokens.next(); + + if (!b_positive_integer_ok(variable_size.c_str())) + { + llerrs << "not a legal integer variable size: " << variable_size + << " at " << tokens.line() << llendl; + } + + EMsgVariableType type_enum; + if(var_type == "Variable") + { + type_enum = MVT_VARIABLE; + } + else if(var_type == "Fixed") + { + type_enum = MVT_FIXED; + } + else + { + type_enum = MVT_FIXED; // removes a warning + llerrs << "bad variable type: " << var_type + << " at " << tokens.line() << llendl; + } + + varp = new LLMessageVariable( + var_name.c_str(), + type_enum, + atoi(variable_size.c_str())); + } + else + { + llerrs << "bad variable type:" << var_type + << " at " << tokens.line() << llendl; + } + + if(!tokens.want("}")) + { + llerrs << "Expecting closing } for variable " << var_name + << " at " << tokens.line() << llendl; + } + return varp; +} diff --git a/indra/llmessage/llmessagetemplateparser.h b/indra/llmessage/llmessagetemplateparser.h new file mode 100644 index 0000000000..0fba42bc41 --- /dev/null +++ b/indra/llmessage/llmessagetemplateparser.h @@ -0,0 +1,62 @@ +/** + * @file llmessagetemplateparser.h + * @brief Classes to parse message template. + * + * Copyright (c) 2000-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + +#ifndef LL_MESSAGETEMPLATEPARSER_H +#define LL_MESSAGETEMPLATEPARSER_H + +#include <string> +#include "llmessagetemplate.h" + +class LLTemplateTokenizer +{ +public: + LLTemplateTokenizer(const std::string & contents); + + U32 line() const; + bool atEOF() const; + std::string next(); + + bool want(const std::string & token); + bool wantEOF(); +private: + void inc(); + void dec(); + std::string get() const; + void error(std::string message = "generic") const; + + struct positioned_token + { + std::string str; + U32 line; + }; + + bool mStarted; + std::list<positioned_token> mTokens; + std::list<positioned_token>::const_iterator mCurrent; +}; + +class LLTemplateParser +{ +public: + typedef std::list<LLMessageTemplate *>::const_iterator message_iterator; + + static LLMessageTemplate * parseMessage(LLTemplateTokenizer & tokens); + static LLMessageBlock * parseBlock(LLTemplateTokenizer & tokens); + static LLMessageVariable * parseVariable(LLTemplateTokenizer & tokens); + + LLTemplateParser(LLTemplateTokenizer & tokens); + message_iterator getMessagesBegin() const; + message_iterator getMessagesEnd() const; + F32 getVersion() const; + +private: + F32 mVersion; + std::list<LLMessageTemplate *> mMessages; +}; + +#endif diff --git a/indra/llmessage/llmsgvariabletype.h b/indra/llmessage/llmsgvariabletype.h index 360d949690..23370d2f48 100644 --- a/indra/llmessage/llmsgvariabletype.h +++ b/indra/llmessage/llmsgvariabletype.h @@ -1,3 +1,11 @@ +/** + * @file llmsgvariabletype.h + * @brief Declaration of the EMsgVariableType enumeration. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #ifndef LL_LLMSGVARIABLETYPE_H #define LL_LLMSGVARIABLETYPE_H diff --git a/indra/llmessage/llpacketack.cpp b/indra/llmessage/llpacketack.cpp new file mode 100644 index 0000000000..c0c8028ca3 --- /dev/null +++ b/indra/llmessage/llpacketack.cpp @@ -0,0 +1,64 @@ +/** + * @file llpacketack.cpp + * @author Phoenix + * @date 2007-05-09 + * @brief Implementation of the LLReliablePacket. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + +#include "linden_common.h" +#include "llpacketack.h" + +#if !LL_WINDOWS +#include <netinet/in.h> +#else +#include "winsock2.h" +#endif + +#include "message.h" + +LLReliablePacket::LLReliablePacket( + S32 socket, + U8* buf_ptr, + S32 buf_len, + LLReliablePacketParams* params) : + mBuffer(NULL), + mBufferLength(0) +{ + if (params) + { + mHost = params->mHost; + mRetries = params->mRetries; + mPingBasedRetry = params->mPingBasedRetry; + mTimeout = params->mTimeout; + mCallback = params->mCallback; + mCallbackData = params->mCallbackData; + mMessageName = params->mMessageName; + } + else + { + mRetries = 0; + mPingBasedRetry = TRUE; + mTimeout = 0.f; + mCallback = NULL; + mCallbackData = NULL; + mMessageName = NULL; + } + + mExpirationTime = (F64)((S64)totalTime())/1000000.0 + mTimeout; + mPacketID = ntohl(*((U32*)(&buf_ptr[PHL_PACKET_ID]))); + + mSocket = socket; + if (mRetries) + { + mBuffer = new U8[buf_len]; + if (mBuffer != NULL) + { + memcpy(mBuffer,buf_ptr,buf_len); /*Flawfinder: ignore*/ + mBufferLength = buf_len; + } + + } +} diff --git a/indra/llmessage/llpacketack.h b/indra/llmessage/llpacketack.h index 4c22dc2d62..37675d2df4 100644 --- a/indra/llmessage/llpacketack.h +++ b/indra/llmessage/llpacketack.h @@ -9,37 +9,18 @@ #ifndef LL_LLPACKETACK_H #define LL_LLPACKETACK_H -#include <cstring> -#include <stdio.h> - -#include "llerror.h" -#include "lltimer.h" #include "llhost.h" -//class LLPacketAck -//{ -//public: -// LLHost mHost; -// TPACKETID mPacketID; -//public: -// LLPacketAck(const LLHost &host, TPACKETID packet_id) -// { -// mHost = host; -// mPacketID = packet_id; -// }; -// ~LLPacketAck(){}; -//}; - class LLReliablePacketParams { public: - LLHost mHost; - S32 mRetries; - BOOL mPingBasedRetry; - F32 mTimeout; - void (*mCallback)(void **,S32); - void **mCallbackData; - char *mMessageName; + LLHost mHost; + S32 mRetries; + BOOL mPingBasedRetry; + F32 mTimeout; + void (*mCallback)(void **,S32); + void** mCallbackData; + char* mMessageName; public: LLReliablePacketParams() @@ -60,9 +41,13 @@ public: mMessageName = NULL; }; - void set ( const LLHost &host, S32 retries, BOOL ping_based_retry, - F32 timeout, - void (*callback)(void **,S32), void **callback_data, char *name ) + void set( + const LLHost& host, + S32 retries, + BOOL ping_based_retry, + F32 timeout, + void (*callback)(void**,S32), + void** callback_data, char* name) { mHost = host; mRetries = retries; @@ -77,53 +62,11 @@ public: class LLReliablePacket { public: - LLReliablePacket(S32 socket, U8 *buf_ptr, S32 buf_len, LLReliablePacketParams *params) : - mBuffer(NULL), - mBufferLength(0) - { - if (params) - { - mHost = params->mHost; - mRetries = params->mRetries; - mPingBasedRetry = params->mPingBasedRetry; - mTimeout = params->mTimeout; - mCallback = params->mCallback; - mCallbackData = params->mCallbackData; - mMessageName = params->mMessageName; - } - else - { - mRetries = 0; - mPingBasedRetry = TRUE; - mTimeout = 0.f; - mCallback = NULL; - mCallbackData = NULL; - mMessageName = NULL; - } - - mExpirationTime = (F64)((S64)totalTime())/1000000.0 + mTimeout; - mPacketID = buf_ptr[1] + ((buf_ptr[0] & 0x0f ) * 256); - if (sizeof(TPACKETID) == 4) - { - mPacketID *= 256; - mPacketID += buf_ptr[2]; - mPacketID *= 256; - mPacketID += buf_ptr[3]; - } - - mSocket = socket; - if (mRetries) - { - mBuffer = new U8[buf_len]; - if (mBuffer != NULL) - { - memcpy(mBuffer,buf_ptr,buf_len); /*Flawfinder: ignore*/ - mBufferLength = buf_len; - } - - } - }; - + LLReliablePacket( + S32 socket, + U8* buf_ptr, + S32 buf_len, + LLReliablePacketParams* params); ~LLReliablePacket() { mCallback = NULL; @@ -133,22 +76,21 @@ public: friend class LLCircuitData; protected: - S32 mSocket; - LLHost mHost; - S32 mRetries; - BOOL mPingBasedRetry; - F32 mTimeout; - void (*mCallback)(void **,S32); - void **mCallbackData; - char *mMessageName; - - U8 *mBuffer; - S32 mBufferLength; + S32 mSocket; + LLHost mHost; + S32 mRetries; + BOOL mPingBasedRetry; + F32 mTimeout; + void (*mCallback)(void**,S32); + void** mCallbackData; + char* mMessageName; + + U8* mBuffer; + S32 mBufferLength; - TPACKETID mPacketID; + TPACKETID mPacketID; - F64 mExpirationTime; - + F64 mExpirationTime; }; #endif diff --git a/indra/llmessage/llsdmessagebuilder.cpp b/indra/llmessage/llsdmessagebuilder.cpp index b7deb4817f..94d2378050 100755 --- a/indra/llmessage/llsdmessagebuilder.cpp +++ b/indra/llmessage/llsdmessagebuilder.cpp @@ -1,3 +1,11 @@ +/** + * @file llsdmessagebuilder.cpp + * @brief LLSDMessageBuilder class implementation. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #include "linden_common.h" #include "llsdmessagebuilder.h" @@ -28,13 +36,13 @@ LLSDMessageBuilder::~LLSDMessageBuilder() // virtual -void LLSDMessageBuilder::newMessage(const char *name) +void LLSDMessageBuilder::newMessage(const char* name) { mbSBuilt = FALSE; mbSClear = FALSE; mCurrentMessage = LLSD::emptyMap(); - mCurrentMessageName = (char *)name; + mCurrentMessageName = (char*)name; } // virtual @@ -74,8 +82,10 @@ BOOL LLSDMessageBuilder::removeLastBlock() return FALSE; } -void LLSDMessageBuilder::addBinaryData(const char *varname, - const void *data, S32 size) +void LLSDMessageBuilder::addBinaryData( + const char* varname, + const void* data, + S32 size) { std::vector<U8> v; v.resize(size); @@ -83,57 +93,57 @@ void LLSDMessageBuilder::addBinaryData(const char *varname, (*mCurrentBlock)[varname] = v; } -void LLSDMessageBuilder::addS8(const char *varname, S8 v) +void LLSDMessageBuilder::addS8(const char* varname, S8 v) { (*mCurrentBlock)[varname] = v; } -void LLSDMessageBuilder::addU8(const char *varname, U8 v) +void LLSDMessageBuilder::addU8(const char* varname, U8 v) { (*mCurrentBlock)[varname] = v; } -void LLSDMessageBuilder::addS16(const char *varname, S16 v) +void LLSDMessageBuilder::addS16(const char* varname, S16 v) { (*mCurrentBlock)[varname] = v; } -void LLSDMessageBuilder::addU16(const char *varname, U16 v) +void LLSDMessageBuilder::addU16(const char* varname, U16 v) { (*mCurrentBlock)[varname] = v; } -void LLSDMessageBuilder::addF32(const char *varname, F32 v) +void LLSDMessageBuilder::addF32(const char* varname, F32 v) { (*mCurrentBlock)[varname] = v; } -void LLSDMessageBuilder::addS32(const char *varname, S32 v) +void LLSDMessageBuilder::addS32(const char* varname, S32 v) { (*mCurrentBlock)[varname] = v; } -void LLSDMessageBuilder::addU32(const char *varname, U32 v) +void LLSDMessageBuilder::addU32(const char* varname, U32 v) { (*mCurrentBlock)[varname] = ll_sd_from_U32(v); } -void LLSDMessageBuilder::addU64(const char *varname, U64 v) +void LLSDMessageBuilder::addU64(const char* varname, U64 v) { (*mCurrentBlock)[varname] = ll_sd_from_U64(v); } -void LLSDMessageBuilder::addF64(const char *varname, F64 v) +void LLSDMessageBuilder::addF64(const char* varname, F64 v) { (*mCurrentBlock)[varname] = v; } -void LLSDMessageBuilder::addIPAddr(const char *varname, U32 v) +void LLSDMessageBuilder::addIPAddr(const char* varname, U32 v) { (*mCurrentBlock)[varname] = ll_sd_from_ipaddr(v); } -void LLSDMessageBuilder::addIPPort(const char *varname, U16 v) +void LLSDMessageBuilder::addIPPort(const char* varname, U16 v) { (*mCurrentBlock)[varname] = v; } @@ -159,27 +169,27 @@ void LLSDMessageBuilder::addString(const char* varname, const std::string& v) (*mCurrentBlock)[varname] = ""; } -void LLSDMessageBuilder::addVector3(const char *varname, const LLVector3& v) +void LLSDMessageBuilder::addVector3(const char* varname, const LLVector3& v) { (*mCurrentBlock)[varname] = ll_sd_from_vector3(v); } -void LLSDMessageBuilder::addVector4(const char *varname, const LLVector4& v) +void LLSDMessageBuilder::addVector4(const char* varname, const LLVector4& v) { (*mCurrentBlock)[varname] = ll_sd_from_vector4(v); } -void LLSDMessageBuilder::addVector3d(const char *varname, const LLVector3d& v) +void LLSDMessageBuilder::addVector3d(const char* varname, const LLVector3d& v) { (*mCurrentBlock)[varname] = ll_sd_from_vector3d(v); } -void LLSDMessageBuilder::addQuat(const char *varname, const LLQuaternion& v) +void LLSDMessageBuilder::addQuat(const char* varname, const LLQuaternion& v) { (*mCurrentBlock)[varname] = ll_sd_from_quaternion(v); } -void LLSDMessageBuilder::addUUID(const char *varname, const LLUUID& v) +void LLSDMessageBuilder::addUUID(const char* varname, const LLUUID& v) { (*mCurrentBlock)[varname] = v; } @@ -193,9 +203,7 @@ BOOL LLSDMessageBuilder::isMessageFull(const char* blockname) const return FALSE; } -// make sure that all the desired data is in place and then copy the data -// into MAX_BUFFER_SIZEd buffer -U32 LLSDMessageBuilder::buildMessage(U8* buffer, U32 buffer_size) +U32 LLSDMessageBuilder::buildMessage(U8*, U32, U8) { return 0; } @@ -205,7 +213,7 @@ void LLSDMessageBuilder::copyFromMessageData(const LLMsgData& data) // copy the blocks // counting variables used to encode multiple block info S32 block_count = 0; - char *block_name = NULL; + char* block_name = NULL; // loop through msg blocks to loop through variables, totalling up size // data and filling the new (send) message @@ -222,7 +230,7 @@ void LLSDMessageBuilder::copyFromMessageData(const LLMsgData& data) if (block_count == 0) { block_count = mbci->mBlockNumber; - block_name = (char *)mbci->mName; + block_name = (char*)mbci->mName; } // counting down mutliple blocks @@ -248,7 +256,7 @@ void LLSDMessageBuilder::copyFromMessageData(const LLMsgData& data) void LLSDMessageBuilder::copyFromLLSD(const LLSD& msg) { mCurrentMessage = msg; - llinfos << LLSDXMLStreamer(mCurrentMessage) << llendl; + lldebugs << LLSDXMLStreamer(mCurrentMessage) << llendl; } const LLSD& LLSDMessageBuilder::getMessage() const diff --git a/indra/llmessage/llsdmessagebuilder.h b/indra/llmessage/llsdmessagebuilder.h index f04194d12f..4e0d71fd8b 100755 --- a/indra/llmessage/llsdmessagebuilder.h +++ b/indra/llmessage/llsdmessagebuilder.h @@ -1,3 +1,11 @@ +/** + * @file llsdmessagebuilder.h + * @brief Declaration of LLSDMessageBuilder class. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #ifndef LL_LLSDMESSAGEBUILDER_H #define LL_LLSDMESSAGEBUILDER_H @@ -19,31 +27,33 @@ public: LLSDMessageBuilder(); virtual ~LLSDMessageBuilder(); - virtual void newMessage(const char *name); + virtual void newMessage(const char* name); virtual void nextBlock(const char* blockname); virtual BOOL removeLastBlock(); // TODO: babbage: remove this horror... /** All add* methods expect pointers to canonical varname strings. */ - virtual void addBinaryData(const char *varname, const void *data, - S32 size); + virtual void addBinaryData( + const char* varname, + const void* data, + S32 size); virtual void addBOOL(const char* varname, BOOL b); - virtual void addS8(const char *varname, S8 s); - virtual void addU8(const char *varname, U8 u); - virtual void addS16(const char *varname, S16 i); - virtual void addU16(const char *varname, U16 i); - virtual void addF32(const char *varname, F32 f); - virtual void addS32(const char *varname, S32 s); - virtual void addU32(const char *varname, U32 u); - virtual void addU64(const char *varname, U64 lu); - virtual void addF64(const char *varname, F64 d); - virtual void addVector3(const char *varname, const LLVector3& vec); - virtual void addVector4(const char *varname, const LLVector4& vec); - virtual void addVector3d(const char *varname, const LLVector3d& vec); - virtual void addQuat(const char *varname, const LLQuaternion& quat); - virtual void addUUID(const char *varname, const LLUUID& uuid); - virtual void addIPAddr(const char *varname, const U32 ip); - virtual void addIPPort(const char *varname, const U16 port); + virtual void addS8(const char* varname, S8 s); + virtual void addU8(const char* varname, U8 u); + virtual void addS16(const char* varname, S16 i); + virtual void addU16(const char* varname, U16 i); + virtual void addF32(const char* varname, F32 f); + virtual void addS32(const char* varname, S32 s); + virtual void addU32(const char* varname, U32 u); + virtual void addU64(const char* varname, U64 lu); + virtual void addF64(const char* varname, F64 d); + virtual void addVector3(const char* varname, const LLVector3& vec); + virtual void addVector4(const char* varname, const LLVector4& vec); + virtual void addVector3d(const char* varname, const LLVector3d& vec); + virtual void addQuat(const char* varname, const LLQuaternion& quat); + virtual void addUUID(const char* varname, const LLUUID& uuid); + virtual void addIPAddr(const char* varname, const U32 ip); + virtual void addIPPort(const char* varname, const U16 port); virtual void addString(const char* varname, const char* s); virtual void addString(const char* varname, const std::string& s); @@ -52,8 +62,8 @@ public: virtual BOOL isBuilt() const; virtual BOOL isClear() const; - virtual U32 buildMessage(U8* buffer, U32 buffer_size); - /**< Return built message size */ + virtual U32 buildMessage(U8* buffer, U32 buffer_size, U8 offset_to_data); + /**< Null implementation which returns 0. */ virtual void clearMessage(); diff --git a/indra/llmessage/llsdmessagereader.cpp b/indra/llmessage/llsdmessagereader.cpp index 6312bee0ab..889cb305c2 100755 --- a/indra/llmessage/llsdmessagereader.cpp +++ b/indra/llmessage/llsdmessagereader.cpp @@ -1,7 +1,18 @@ +/** + * @file llsdmessagereader.cpp + * @brief LLSDMessageReader class implementation. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + +#include "linden_common.h" + #include "llsdmessagereader.h" -#include "llsdutil.h" + #include "llmessagebuilder.h" #include "llsdmessagebuilder.h" +#include "llsdutil.h" LLSDMessageReader::LLSDMessageReader() { @@ -15,11 +26,30 @@ LLSDMessageReader::~LLSDMessageReader() LLSD getLLSD(const LLSD& input, const char* block, const char* var, S32 blocknum) { - if(input[block].isArray()) + // babbage: log error to llerrs if variable not found to mimic + // LLTemplateMessageReader::getData behaviour + if(NULL == block) + { + llerrs << "NULL block name" << llendl; + return LLSD(); + } + if(NULL == var) + { + llerrs << "NULL var name" << llendl; + return LLSD(); + } + if(! input[block].isArray()) + { + llerrs << "block " << block << " not found" << llendl; + return LLSD(); + } + + LLSD result = input[block][blocknum][var]; + if(result.isUndefined()) { - return input[block][blocknum][var]; + llerrs << "var " << var << " not found" << llendl; } - return LLSD(); + return result; } //virtual @@ -167,8 +197,12 @@ void LLSDMessageReader::getIPPort(const char *block, const char *var, void LLSDMessageReader::getString(const char *block, const char *var, S32 buffer_size, char *buffer, S32 blocknum) { + if(buffer_size <= 0) + { + llwarns << "buffer_size <= 0" << llendl; + return; + } std::string data = getLLSD(mMessage, block, var, blocknum); - S32 data_size = data.size(); if (data_size >= buffer_size) { @@ -241,7 +275,7 @@ void LLSDMessageReader::clearMessage() //virtual const char* LLSDMessageReader::getMessageName() const { - return mMessageName.c_str(); + return mMessageName; } // virtual @@ -256,7 +290,7 @@ void LLSDMessageReader::copyToBuilder(LLMessageBuilder& builder) const builder.copyFromLLSD(mMessage); } -void LLSDMessageReader::setMessage(const std::string& name, const LLSD& message) +void LLSDMessageReader::setMessage(const char* name, const LLSD& message) { mMessageName = name; // TODO: Validate diff --git a/indra/llmessage/llsdmessagereader.h b/indra/llmessage/llsdmessagereader.h index 57851941a2..d6d9f3d2f9 100755 --- a/indra/llmessage/llsdmessagereader.h +++ b/indra/llmessage/llsdmessagereader.h @@ -69,10 +69,11 @@ public: virtual void copyToBuilder(LLMessageBuilder&) const; - void setMessage(const std::string& name, const LLSD& msg); + /** Expects a pointer to a canonical name string */ + void setMessage(const char* name, const LLSD& msg); private: - std::string mMessageName; + const char* mMessageName; // Canonical (prehashed) string. LLSD mMessage; }; diff --git a/indra/llmessage/lltemplatemessagebuilder.cpp b/indra/llmessage/lltemplatemessagebuilder.cpp index 806f03422d..18e96f26e4 100644 --- a/indra/llmessage/lltemplatemessagebuilder.cpp +++ b/indra/llmessage/lltemplatemessagebuilder.cpp @@ -1,3 +1,11 @@ +/** + * @file lltemplatemessagebuilder.cpp + * @brief LLTemplateMessageBuilder class implementation. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #include "linden_common.h" #include "lltemplatemessagebuilder.h" @@ -41,28 +49,30 @@ void LLTemplateMessageBuilder::newMessage(const char *name) delete mCurrentSMessageData; mCurrentSMessageData = NULL; - char *namep = (char *)name; - + char* namep = (char*)name; if (mMessageTemplates.count(namep) > 0) { mCurrentSMessageTemplate = mMessageTemplates[namep]; - if (mCurrentSMessageData) - { - delete mCurrentSMessageData; - } mCurrentSMessageData = new LLMsgData(namep); mCurrentSMessageName = namep; mCurrentSDataBlock = NULL; mCurrentSBlockName = NULL; // add at one of each block - LLMessageTemplate* msg_template = mMessageTemplates[namep]; - for (LLMessageTemplate::message_block_map_t::iterator iter = msg_template->mMemberBlocks.begin(); - iter != msg_template->mMemberBlocks.end(); iter++) + const LLMessageTemplate* msg_template = mMessageTemplates[namep]; + + if (msg_template->getDeprecation() != MD_NOTDEPRECATED) { - LLMessageBlock* ci = iter->second; - LLMsgBlkData *tblockp; - tblockp = new LLMsgBlkData(ci->mName, 0); + llwarns << "Sending deprecated message " << namep << llendl; + } + + LLMessageTemplate::message_block_map_t::const_iterator iter; + for(iter = msg_template->mMemberBlocks.begin(); + iter != msg_template->mMemberBlocks.end(); + ++iter) + { + LLMessageBlock* ci = *iter; + LLMsgBlkData* tblockp = new LLMsgBlkData(ci->mName, 0); mCurrentSMessageData->addBlock(tblockp); } } @@ -102,16 +112,14 @@ void LLTemplateMessageBuilder::nextBlock(const char* blockname) } // now, does this block exist? - LLMessageTemplate::message_block_map_t::iterator temp_iter = mCurrentSMessageTemplate->mMemberBlocks.find(bnamep); - if (temp_iter == mCurrentSMessageTemplate->mMemberBlocks.end()) + const LLMessageBlock* template_data = mCurrentSMessageTemplate->getBlock(bnamep); + if (!template_data) { llerrs << "LLTemplateMessageBuilder::nextBlock " << bnamep << " not a block in " << mCurrentSMessageTemplate->mName << llendl; return; } - LLMessageBlock* template_data = temp_iter->second; - // ok, have we already set this block? LLMsgBlkData* block_data = mCurrentSMessageData->mMemberBlocks[bnamep]; if (block_data->mBlockNumber == 0) @@ -122,10 +130,10 @@ void LLTemplateMessageBuilder::nextBlock(const char* blockname) mCurrentSBlockName = bnamep; // add placeholders for each of the variables - for (LLMessageBlock::message_variable_map_t::iterator iter = template_data->mMemberVariables.begin(); + for (LLMessageBlock::message_variable_map_t::const_iterator iter = template_data->mMemberVariables.begin(); iter != template_data->mMemberVariables.end(); iter++) { - LLMessageVariable& ci = *(iter->second); + LLMessageVariable& ci = **iter; mCurrentSDataBlock->addVariable(ci.getName(), ci.getType()); } return; @@ -181,12 +189,12 @@ void LLTemplateMessageBuilder::nextBlock(const char* blockname) mCurrentSMessageData->mMemberBlocks[nbnamep] = mCurrentSDataBlock; // add placeholders for each of the variables - for (LLMessageBlock::message_variable_map_t::iterator + for (LLMessageBlock::message_variable_map_t::const_iterator iter = template_data->mMemberVariables.begin(), end = template_data->mMemberVariables.end(); iter != end; iter++) { - LLMessageVariable& ci = *(iter->second); + LLMessageVariable& ci = **iter; mCurrentSDataBlock->addVariable(ci.getName(), ci.getType()); } return; @@ -211,12 +219,12 @@ BOOL LLTemplateMessageBuilder::removeLastBlock() // Decrement the sent total by the size of the // data in the message block that we're currently building. - LLMessageBlock* template_data = mCurrentSMessageTemplate->mMemberBlocks[mCurrentSBlockName]; + const LLMessageBlock* template_data = mCurrentSMessageTemplate->getBlock(mCurrentSBlockName); - for (LLMessageBlock::message_variable_map_t::iterator iter = template_data->mMemberVariables.begin(); + for (LLMessageBlock::message_variable_map_t::const_iterator iter = template_data->mMemberVariables.begin(); iter != template_data->mMemberVariables.end(); iter++) { - LLMessageVariable& ci = *(iter->second); + LLMessageVariable& ci = **iter; mCurrentSendTotal -= ci.getSize(); } @@ -276,7 +284,7 @@ void LLTemplateMessageBuilder::addData(const char *varname, const void *data, EM } // kewl, add the data if it exists - LLMessageVariable* var_data = mCurrentSMessageTemplate->mMemberBlocks[mCurrentSBlockName]->mMemberVariables[vnamep]; + const LLMessageVariable* var_data = mCurrentSMessageTemplate->getBlock(mCurrentSBlockName)->getVariable(vnamep); if (!var_data || !var_data->getName()) { llerrs << vnamep << " not a variable in block " << mCurrentSBlockName << " of " << mCurrentSMessageTemplate->mName << llendl; @@ -336,7 +344,7 @@ void LLTemplateMessageBuilder::addData(const char *varname, const void *data, EM } // kewl, add the data if it exists - LLMessageVariable* var_data = mCurrentSMessageTemplate->mMemberBlocks[mCurrentSBlockName]->mMemberVariables[vnamep]; + const LLMessageVariable* var_data = mCurrentSMessageTemplate->getBlock(mCurrentSBlockName)->getVariable(vnamep); if (!var_data->getName()) { llerrs << vnamep << " not a variable in block " << mCurrentSBlockName << " of " << mCurrentSMessageTemplate->mName << llendl; @@ -484,7 +492,7 @@ static S32 zero_code(U8 **data, U32 *data_size) // skip the packet id field - for (U32 i=0;i<LL_PACKET_ID_SIZE;i++) + for (U32 ii = 0; ii < LL_PACKET_ID_SIZE ; ++ii) { count--; *outptr++ = *inptr++; @@ -571,7 +579,7 @@ BOOL LLTemplateMessageBuilder::isMessageFull(const char* blockname) const char* bnamep = (char*)blockname; S32 max; - LLMessageBlock* template_data = mCurrentSMessageTemplate->mMemberBlocks[bnamep]; + const LLMessageBlock* template_data = mCurrentSMessageTemplate->getBlock(bnamep); switch(template_data->mType) { @@ -593,138 +601,59 @@ BOOL LLTemplateMessageBuilder::isMessageFull(const char* blockname) const return FALSE; } - -// make sure that all the desired data is in place and then copy the data into MAX_BUFFER_SIZEd buffer -U32 LLTemplateMessageBuilder::buildMessage(U8* buffer, U32 buffer_size) +static S32 buildBlock(U8* buffer, S32 buffer_size, const LLMessageBlock* template_data, LLMsgData* message_data) { - // basic algorithm is to loop through the various pieces, building - // size and offset info if we encounter a -1 for mSize at any - // point that variable wasn't given data - - // do we have a current message? - if (!mCurrentSMessageTemplate) - { - llerrs << "newMessage not called prior to buildMessage" << llendl; - return 0; - } - - // zero out some useful values - - // leave room for circuit counter - U32 result = LL_PACKET_ID_SIZE; - - // encode message number and adjust total_offset - if (mCurrentSMessageTemplate->mFrequency == MFT_HIGH) - { -// old, endian-dependant way -// memcpy(&buffer[result], &mCurrentMessageTemplate->mMessageNumber, sizeof(U8)); - -// new, independant way - buffer[result] = (U8)mCurrentSMessageTemplate->mMessageNumber; - result += sizeof(U8); - } - else if (mCurrentSMessageTemplate->mFrequency == MFT_MEDIUM) - { - U8 temp = 255; - memcpy(&buffer[result], &temp, sizeof(U8)); /*Flawfinder: ignore*/ - result += sizeof(U8); - - // mask off unsightly bits - temp = mCurrentSMessageTemplate->mMessageNumber & 255; - memcpy(&buffer[result], &temp, sizeof(U8)); /*Flawfinder: ignore*/ - result += sizeof(U8); - } - else if (mCurrentSMessageTemplate->mFrequency == MFT_LOW) - { - U8 temp = 255; - U16 message_num; - memcpy(&buffer[result], &temp, sizeof(U8)); /*Flawfinder: ignore*/ - result += sizeof(U8); - memcpy(&buffer[result], &temp, sizeof(U8)); /*Flawfinder: ignore*/ - result += sizeof(U8); - - // mask off unsightly bits - message_num = mCurrentSMessageTemplate->mMessageNumber & 0xFFFF; - - // convert to network byte order - message_num = htons(message_num); - memcpy(&buffer[result], &message_num, sizeof(U16)); /*Flawfinder: ignore*/ - result += sizeof(U16); - } - else - { - llerrs << "unexpected message frequency in buildMessage" << llendl; - return 0; + S32 result = 0; + LLMsgData::msg_blk_data_map_t::const_iterator block_iter = message_data->mMemberBlocks.find(template_data->mName); + const LLMsgBlkData* mbci = block_iter->second; + + // ok, if this is the first block of a repeating pack, set + // block_count and, if it's type MBT_VARIABLE encode a byte + // for how many there are + S32 block_count = mbci->mBlockNumber; + if (template_data->mType == MBT_VARIABLE) + { + // remember that mBlockNumber is a S32 + U8 temp_block_number = (U8)mbci->mBlockNumber; + if ((S32)(result + sizeof(U8)) < MAX_BUFFER_SIZE) + { + memcpy(&buffer[result], &temp_block_number, sizeof(U8)); + result += sizeof(U8); + } + else + { + // Just reporting error is likely not enough. Need + // to check how to abort or error out gracefully + // from this function. XXXTBD + llerrs << "buildBlock failed. Message excedding " + << "sendBuffersize." << llendl; + } } - - // counting variables used to encode multiple block info - S32 block_count = 0; - U8 temp_block_number; - - // loop through msg blocks to loop through variables, - // totalling up size data and copying into buffer - for (LLMsgData::msg_blk_data_map_t::iterator - iter = mCurrentSMessageData->mMemberBlocks.begin(), - end = mCurrentSMessageData->mMemberBlocks.end(); - iter != end; iter++) + else if (template_data->mType == MBT_MULTIPLE) { - LLMsgBlkData* mbci = iter->second; - // do we need to encode a block code? - if (block_count == 0) + if (block_count != template_data->mNumber) { - block_count = mbci->mBlockNumber; - - LLMessageBlock* template_data = - mCurrentSMessageTemplate->mMemberBlocks[mbci->mName]; - - // ok, if this is the first block of a repeating pack, set - // block_count and, if it's type MBT_VARIABLE encode a byte - // for how many there are - if (template_data->mType == MBT_VARIABLE) - { - // remember that mBlockNumber is a S32 - temp_block_number = (U8)mbci->mBlockNumber; - if ((S32)(result + sizeof(U8)) < MAX_BUFFER_SIZE) - { - memcpy(&buffer[result], &temp_block_number, sizeof(U8)); - result += sizeof(U8); - } - else - { - // Just reporting error is likely not enough. Need - // to check how to abort or error out gracefully - // from this function. XXXTBD - llerrs << "buildMessage failed. Message excedding " - << "sendBuffersize." << llendl; - } - } - else if (template_data->mType == MBT_MULTIPLE) - { - if (block_count != template_data->mNumber) - { - // nope! need to fill it in all the way! - llerrs << "Block " << mbci->mName - << " is type MBT_MULTIPLE but only has data for " - << block_count << " out of its " - << template_data->mNumber << " blocks" << llendl; - } - } + // nope! need to fill it in all the way! + llerrs << "Block " << mbci->mName + << " is type MBT_MULTIPLE but only has data for " + << block_count << " out of its " + << template_data->mNumber << " blocks" << llendl; } + } - // counting down multiple blocks - block_count--; - + while(block_count > 0) + { // now loop through the variables - for (LLMsgBlkData::msg_var_data_map_t::iterator iter = mbci->mMemberVarData.begin(); + for (LLMsgBlkData::msg_var_data_map_t::const_iterator iter = mbci->mMemberVarData.begin(); iter != mbci->mMemberVarData.end(); iter++) { - LLMsgVarData& mvci = *iter; + const LLMsgVarData& mvci = *iter; if (mvci.getSize() == -1) { // oops, this variable wasn't ever set! llerrs << "The variable " << mvci.getName() << " in block " << mbci->mName << " of message " - << mCurrentSMessageData->mName + << template_data->mName << " wasn't set prior to buildMessage call" << llendl; } else @@ -774,7 +703,7 @@ U32 LLTemplateMessageBuilder::buildMessage(U8* buffer, U32 buffer_size) // Just reporting error is likely not // enough. Need to check how to abort or error // out gracefully from this function. XXXTBD - llerrs << "LLMessageSystem::buildMessage failed. " + llerrs << "buildBlock failed. " << "Attempted to pack " << result + mvci.getSize() << " bytes into a buffer with size " @@ -783,6 +712,94 @@ U32 LLTemplateMessageBuilder::buildMessage(U8* buffer, U32 buffer_size) } } } + + --block_count; + ++block_iter; + if (block_iter != message_data->mMemberBlocks.end()) + { + mbci = block_iter->second; + } + } + + return result; +} + + +// make sure that all the desired data is in place and then copy the data into MAX_BUFFER_SIZEd buffer +U32 LLTemplateMessageBuilder::buildMessage( + U8* buffer, + U32 buffer_size, + U8 offset_to_data) +{ + // basic algorithm is to loop through the various pieces, building + // size and offset info if we encounter a -1 for mSize at any + // point that variable wasn't given data + + // do we have a current message? + if (!mCurrentSMessageTemplate) + { + llerrs << "newMessage not called prior to buildMessage" << llendl; + return 0; + } + + // leave room for flags, packet sequence #, and data offset + // information. + buffer[PHL_OFFSET] = offset_to_data; + U32 result = LL_PACKET_ID_SIZE; + + // encode message number and adjust total_offset + if (mCurrentSMessageTemplate->mFrequency == MFT_HIGH) + { +// old, endian-dependant way +// memcpy(&buffer[result], &mCurrentMessageTemplate->mMessageNumber, sizeof(U8)); + +// new, independant way + buffer[result] = (U8)mCurrentSMessageTemplate->mMessageNumber; + result += sizeof(U8); + } + else if (mCurrentSMessageTemplate->mFrequency == MFT_MEDIUM) + { + U8 temp = 255; + memcpy(&buffer[result], &temp, sizeof(U8)); /*Flawfinder: ignore*/ + result += sizeof(U8); + + // mask off unsightly bits + temp = mCurrentSMessageTemplate->mMessageNumber & 255; + memcpy(&buffer[result], &temp, sizeof(U8)); /*Flawfinder: ignore*/ + result += sizeof(U8); + } + else if (mCurrentSMessageTemplate->mFrequency == MFT_LOW) + { + U8 temp = 255; + U16 message_num; + memcpy(&buffer[result], &temp, sizeof(U8)); /*Flawfinder: ignore*/ + result += sizeof(U8); + memcpy(&buffer[result], &temp, sizeof(U8)); /*Flawfinder: ignore*/ + result += sizeof(U8); + + // mask off unsightly bits + message_num = mCurrentSMessageTemplate->mMessageNumber & 0xFFFF; + + // convert to network byte order + message_num = htons(message_num); + memcpy(&buffer[result], &message_num, sizeof(U16)); /*Flawfinder: ignore*/ + result += sizeof(U16); + } + else + { + llerrs << "unexpected message frequency in buildMessage" << llendl; + return 0; + } + + // fast forward through the offset and build the message + result += offset_to_data; + for(LLMessageTemplate::message_block_map_t::const_iterator + iter = mCurrentSMessageTemplate->mMemberBlocks.begin(), + end = mCurrentSMessageTemplate->mMemberBlocks.end(); + iter != end; + ++iter) + { + result += buildBlock(buffer + result, buffer_size - result, *iter, mCurrentSMessageData); } mbSBuilt = TRUE; diff --git a/indra/llmessage/lltemplatemessagebuilder.h b/indra/llmessage/lltemplatemessagebuilder.h index ae533288fb..6cc06ee0f3 100644 --- a/indra/llmessage/lltemplatemessagebuilder.h +++ b/indra/llmessage/lltemplatemessagebuilder.h @@ -1,3 +1,11 @@ +/** + * @file lltemplatemessagebuilder.h + * @brief Declaration of LLTemplateMessageBuilder class. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #ifndef LL_LLTEMPLATEMESSAGEBUILDER_H #define LL_LLTEMPLATEMESSAGEBUILDER_H @@ -15,12 +23,12 @@ class LLTemplateMessageBuilder : public LLMessageBuilder { public: - typedef std::map<const char *, LLMessageTemplate*> message_template_name_map_t; + typedef std::map<const char* , LLMessageTemplate*> message_template_name_map_t; LLTemplateMessageBuilder(message_template_name_map_t&); virtual ~LLTemplateMessageBuilder(); - virtual void newMessage(const char *name); + virtual void newMessage(const char* name); virtual void nextBlock(const char* blockname); virtual BOOL removeLastBlock(); // TODO: babbage: remove this horror... @@ -29,22 +37,22 @@ public: virtual void addBinaryData(const char *varname, const void *data, S32 size); virtual void addBOOL(const char* varname, BOOL b); - virtual void addS8(const char *varname, S8 s); - virtual void addU8(const char *varname, U8 u); - virtual void addS16(const char *varname, S16 i); - virtual void addU16(const char *varname, U16 i); - virtual void addF32(const char *varname, F32 f); - virtual void addS32(const char *varname, S32 s); - virtual void addU32(const char *varname, U32 u); - virtual void addU64(const char *varname, U64 lu); - virtual void addF64(const char *varname, F64 d); - virtual void addVector3(const char *varname, const LLVector3& vec); - virtual void addVector4(const char *varname, const LLVector4& vec); - virtual void addVector3d(const char *varname, const LLVector3d& vec); - virtual void addQuat(const char *varname, const LLQuaternion& quat); - virtual void addUUID(const char *varname, const LLUUID& uuid); - virtual void addIPAddr(const char *varname, const U32 ip); - virtual void addIPPort(const char *varname, const U16 port); + virtual void addS8(const char* varname, S8 s); + virtual void addU8(const char* varname, U8 u); + virtual void addS16(const char* varname, S16 i); + virtual void addU16(const char* varname, U16 i); + virtual void addF32(const char* varname, F32 f); + virtual void addS32(const char* varname, S32 s); + virtual void addU32(const char* varname, U32 u); + virtual void addU64(const char* varname, U64 lu); + virtual void addF64(const char* varname, F64 d); + virtual void addVector3(const char* varname, const LLVector3& vec); + virtual void addVector4(const char* varname, const LLVector4& vec); + virtual void addVector3d(const char* varname, const LLVector3d& vec); + virtual void addQuat(const char* varname, const LLQuaternion& quat); + virtual void addUUID(const char* varname, const LLUUID& uuid); + virtual void addIPAddr(const char* varname, const U32 ip); + virtual void addIPPort(const char* varname, const U16 port); virtual void addString(const char* varname, const char* s); virtual void addString(const char* varname, const std::string& s); @@ -53,7 +61,7 @@ public: virtual BOOL isBuilt() const; virtual BOOL isClear() const; - virtual U32 buildMessage(U8* buffer, U32 buffer_size); + virtual U32 buildMessage(U8* buffer, U32 buffer_size, U8 offset_to_data); /**< Return built message size */ virtual void clearMessage(); @@ -68,14 +76,14 @@ public: virtual void copyFromLLSD(const LLSD&); private: - void addData(const char *varname, const void *data, + void addData(const char* varname, const void* data, EMsgVariableType type, S32 size); - void addData(const char *varname, const void *data, + void addData(const char* varname, const void* data, EMsgVariableType type); LLMsgData* mCurrentSMessageData; - LLMessageTemplate* mCurrentSMessageTemplate; + const LLMessageTemplate* mCurrentSMessageTemplate; LLMsgBlkData* mCurrentSDataBlock; char* mCurrentSMessageName; char* mCurrentSBlockName; diff --git a/indra/llmessage/lltemplatemessagereader.cpp b/indra/llmessage/lltemplatemessagereader.cpp index bb3f4f4a15..9015be7106 100644 --- a/indra/llmessage/lltemplatemessagereader.cpp +++ b/indra/llmessage/lltemplatemessagereader.cpp @@ -1,3 +1,11 @@ +/** + * @file lltemplatemessagereader.cpp + * @brief LLTemplateMessageReader class implementation. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #include "lltemplatemessagereader.h" #include "llfasttimer.h" @@ -53,7 +61,7 @@ void LLTemplateMessageReader::getData(const char *blockname, const char *varname char *bnamep = (char *)blockname + blocknum; // this works because it's just a hash. The bnamep is never derefference char *vnamep = (char *)varname; - LLMsgData::msg_blk_data_map_t::iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep); + LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep); if (iter == mCurrentRMessageData->mMemberBlocks.end()) { @@ -135,7 +143,7 @@ S32 LLTemplateMessageReader::getNumberOfBlocks(const char *blockname) char *bnamep = (char *)blockname; - LLMsgData::msg_blk_data_map_t::iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep); + LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep); if (iter == mCurrentRMessageData->mMemberBlocks.end()) { @@ -165,7 +173,7 @@ S32 LLTemplateMessageReader::getSize(const char *blockname, const char *varname) char *bnamep = (char *)blockname; - LLMsgData::msg_blk_data_map_t::iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep); + LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep); if (iter == mCurrentRMessageData->mMemberBlocks.end()) { @@ -214,7 +222,7 @@ S32 LLTemplateMessageReader::getSize(const char *blockname, S32 blocknum, const char *bnamep = (char *)blockname + blocknum; char *vnamep = (char *)varname; - LLMsgData::msg_blk_data_map_t::iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep); + LLMsgData::msg_blk_data_map_t::const_iterator iter = mCurrentRMessageData->mMemberBlocks.find(bnamep); if (iter == mCurrentRMessageData->mMemberBlocks.end()) { @@ -497,16 +505,21 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender llassert( !mCurrentRMessageData ); delete mCurrentRMessageData; // just to make sure - S32 decode_pos = LL_PACKET_ID_SIZE + (S32)(mCurrentRMessageTemplate->mFrequency); + // The offset tells us how may bytes to skip after the end of the + // message name. + U8 offset = buffer[PHL_OFFSET]; + S32 decode_pos = LL_PACKET_ID_SIZE + (S32)(mCurrentRMessageTemplate->mFrequency) + offset; // create base working data set mCurrentRMessageData = new LLMsgData(mCurrentRMessageTemplate->mName); // loop through the template building the data structure as we go - for (LLMessageTemplate::message_block_map_t::iterator iter = mCurrentRMessageTemplate->mMemberBlocks.begin(); - iter != mCurrentRMessageTemplate->mMemberBlocks.end(); iter++) + LLMessageTemplate::message_block_map_t::const_iterator iter; + for(iter = mCurrentRMessageTemplate->mMemberBlocks.begin(); + iter != mCurrentRMessageTemplate->mMemberBlocks.end(); + ++iter) { - LLMessageBlock* mbci = iter->second; + LLMessageBlock* mbci = *iter; U8 repeat_number; S32 i; @@ -528,11 +541,16 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender // repeat number is a single byte if (decode_pos >= mReceiveSize) { - logRanOffEndOfPacket( sender ); - return FALSE; + logRanOffEndOfPacket(sender); + + // default to 0 repeats + repeat_number = 0; + } + else + { + repeat_number = buffer[decode_pos]; + decode_pos++; } - repeat_number = buffer[decode_pos]; - decode_pos++; } else { @@ -561,10 +579,12 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender mCurrentRMessageData->addBlock(cur_data_block); // now read the variables - for (LLMessageBlock::message_variable_map_t::iterator iter = mbci->mMemberVariables.begin(); + for (LLMessageBlock::message_variable_map_t::const_iterator iter = + mbci->mMemberVariables.begin(); iter != mbci->mMemberVariables.end(); iter++) { - LLMessageVariable& mvci = *(iter->second); + const LLMessageVariable& mvci = **iter; + // ok, build out the variables // add variable block cur_data_block->addVariable(mvci.getName(), mvci.getType()); @@ -580,34 +600,33 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender if ((decode_pos + data_size) > mReceiveSize) { - logRanOffEndOfPacket( sender ); - return FALSE; + logRanOffEndOfPacket(sender); + + // default to 0 length variable blocks + tsize = 0; } - switch(data_size) + else { - case 1: - htonmemcpy(&tsizeb, &buffer[decode_pos], MVT_U8, 1); - tsize = tsizeb; - break; - case 2: - htonmemcpy(&tsizeh, &buffer[decode_pos], MVT_U16, 2); - tsize = tsizeh; - break; - case 4: - htonmemcpy(&tsize, &buffer[decode_pos], MVT_U32, 4); - break; - default: - llerrs << "Attempting to read variable field with unknown size of " << data_size << llendl; - break; - + switch(data_size) + { + case 1: + htonmemcpy(&tsizeb, &buffer[decode_pos], MVT_U8, 1); + tsize = tsizeb; + break; + case 2: + htonmemcpy(&tsizeh, &buffer[decode_pos], MVT_U16, 2); + tsize = tsizeh; + break; + case 4: + htonmemcpy(&tsize, &buffer[decode_pos], MVT_U32, 4); + break; + default: + llerrs << "Attempting to read variable field with unknown size of " << data_size << llendl; + break; + } } decode_pos += data_size; - if ((decode_pos + (S32)tsize) > mReceiveSize) - { - logRanOffEndOfPacket( sender ); - return FALSE; - } cur_data_block->addData(mvci.getName(), &buffer[decode_pos], tsize, mvci.getType()); decode_pos += tsize; } @@ -615,14 +634,24 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender { // fixed! // so, copy data pointer and set data size to fixed size - if ((decode_pos + mvci.getSize()) > mReceiveSize) { - logRanOffEndOfPacket( sender ); - return FALSE; + logRanOffEndOfPacket(sender); + + // default to 0s. + U32 size = mvci.getSize(); + std::vector<U8> data(size); + memset(&(data[0]), 0, size); + cur_data_block->addData(mvci.getName(), &(data[0]), + size, mvci.getType()); + } + else + { + cur_data_block->addData(mvci.getName(), + &buffer[decode_pos], + mvci.getSize(), + mvci.getType()); } - - cur_data_block->addData(mvci.getName(), &buffer[decode_pos], mvci.getSize(), mvci.getType()); decode_pos += mvci.getSize(); } } @@ -644,11 +673,6 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender decode_timer.reset(); } - // if( mCurrentRMessageTemplate->mName == _PREHASH_AgentToNewRegion ) - // { - // VTResume(); // VTune - // } - { LLFastTimer t(LLFastTimer::FTM_PROCESS_MESSAGES); if( !mCurrentRMessageTemplate->callHandlerFunc(gMessageSystem) ) @@ -657,11 +681,6 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender } } - // if( mCurrentRMessageTemplate->mName == _PREHASH_AgentToNewRegion ) - // { - // VTPause(); // VTune - // } - if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback()) { F32 decode_time = decode_timer.getElapsedTimeF32(); @@ -723,8 +742,12 @@ BOOL LLTemplateMessageReader::readMessage(const U8* buffer, //virtual const char* LLTemplateMessageReader::getMessageName() const { - static char empty_string[] = ""; - return mCurrentRMessageTemplate ? mCurrentRMessageTemplate->mName : empty_string; + if (!mCurrentRMessageTemplate) + { + llwarns << "no mCurrentRMessageTemplate" << llendl; + return ""; + } + return mCurrentRMessageTemplate->mName; } //virtual diff --git a/indra/llmessage/lltemplatemessagereader.h b/indra/llmessage/lltemplatemessagereader.h index dd5ee393fe..ea8bd52298 100644 --- a/indra/llmessage/lltemplatemessagereader.h +++ b/indra/llmessage/lltemplatemessagereader.h @@ -1,3 +1,11 @@ +/** + * @file lltemplatemessagereader.h + * @brief Declaration of LLTemplateMessageReader class. + * + * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + #ifndef LL_LLTEMPLATEMESSAGEREADER_H #define LL_LLTEMPLATEMESSAGEREADER_H diff --git a/indra/llmessage/lltransfermanager.cpp b/indra/llmessage/lltransfermanager.cpp index 36553f8cf1..5b43ea1bad 100644 --- a/indra/llmessage/lltransfermanager.cpp +++ b/indra/llmessage/lltransfermanager.cpp @@ -581,34 +581,6 @@ void LLTransferManager::processTransferAbort(LLMessageSystem *msgp, void **) //static -void LLTransferManager::processTransferPriority(LLMessageSystem *msgp, void **) -{ - //llinfos << "LLTransferManager::processTransferPacket" << llendl; - - LLUUID transfer_id; - LLTransferChannelType channel_type; - F32 priority = 0.f; - msgp->getUUID("TransferInfo", "TransferID", transfer_id); - msgp->getS32("TransferInfo", "ChannelType", (S32 &)channel_type); - msgp->getF32("TransferInfo", "Priority", priority); - - // Hmm, not a target. Maybe it's a source. - LLTransferSourceChannel *tscp = gTransferManager.getSourceChannel(msgp->getSender(), channel_type); - if (tscp) - { - LLTransferSource *tsp = tscp->findTransferSource(transfer_id); - if (tsp) - { - tscp->updatePriority(tsp, priority); - return; - } - } - - llwarns << "Couldn't find transfer " << transfer_id << " to set priority!" << llendl; -} - - -//static void LLTransferManager::reliablePacketCallback(void **user_data, S32 result) { LLUUID *transfer_idp = (LLUUID *)user_data; diff --git a/indra/llmessage/lltransfermanager.h b/indra/llmessage/lltransfermanager.h index d258bd5f92..af2afa0f06 100644 --- a/indra/llmessage/lltransfermanager.h +++ b/indra/llmessage/lltransfermanager.h @@ -109,7 +109,6 @@ public: static void processTransferInfo(LLMessageSystem *mesgsys, void **); static void processTransferPacket(LLMessageSystem *mesgsys, void **); static void processTransferAbort(LLMessageSystem *mesgsys, void **); - static void processTransferPriority(LLMessageSystem *mesgsys, void **); static void reliablePacketCallback(void **, S32 result); diff --git a/indra/llmessage/message.cpp b/indra/llmessage/message.cpp index 456851a3ec..1a616d9e2b 100644 --- a/indra/llmessage/message.cpp +++ b/indra/llmessage/message.cpp @@ -47,9 +47,12 @@ #include "lltemplatemessagebuilder.h" #include "lltemplatemessagereader.h" #include "llmessagetemplate.h" +#include "llmessagetemplateparser.h" #include "llsd.h" #include "llsdmessagebuilder.h" #include "llsdmessagereader.h" +#include "llsdserialize.h" +#include "llstring.h" #include "lltransfermanager.h" #include "lluuid.h" #include "llxfermanager.h" @@ -80,220 +83,28 @@ public: apr_pollfd_t mPollFD; }; -// Lets support a small subset of regular expressions here -// Syntax is a string made up of: -// a - checks against alphanumeric ([A-Za-z0-9]) -// c - checks against character ([A-Za-z]) -// f - checks against first variable character ([A-Za-z_]) -// v - checks against variable ([A-Za-z0-9_]) -// s - checks against sign of integer ([-0-9]) -// d - checks against integer digit ([0-9]) -// * - repeat last check - -// checks 'a' -BOOL b_return_alphanumeric_ok(char c) -{ - if ( ( (c < 'A') - ||(c > 'Z')) - &&( (c < 'a') - ||(c > 'z')) - &&( (c < '0') - ||(c > '9'))) - { - return FALSE; - } - return TRUE; -} - -// checks 'c' -BOOL b_return_character_ok(char c) -{ - if ( ( (c < 'A') - ||(c > 'Z')) - &&( (c < 'a') - ||(c > 'z'))) - { - return FALSE; - } - return TRUE; -} - -// checks 'f' -BOOL b_return_first_variable_ok(char c) -{ - if ( ( (c < 'A') - ||(c > 'Z')) - &&( (c < 'a') - ||(c > 'z')) - &&(c != '_')) - { - return FALSE; - } - return TRUE; -} - -// checks 'v' -BOOL b_return_variable_ok(char c) -{ - if ( ( (c < 'A') - ||(c > 'Z')) - &&( (c < 'a') - ||(c > 'z')) - &&( (c < '0') - ||(c > '9')) - &&(c != '_')) - { - return FALSE; - } - return TRUE; -} - -// checks 's' -BOOL b_return_signed_integer_ok(char c) -{ - if ( ( (c < '0') - ||(c > '9')) - &&(c != '-')) - { - return FALSE; - } - return TRUE; -} - -// checks 'd' -BOOL b_return_integer_ok(char c) -{ - if ( (c < '0') - ||(c > '9')) - { - return FALSE; - } - return TRUE; -} - -BOOL (*gParseCheckCharacters[])(char c) = -{ - b_return_alphanumeric_ok, - b_return_character_ok, - b_return_first_variable_ok, - b_return_variable_ok, - b_return_signed_integer_ok, - b_return_integer_ok -}; - -S32 get_checker_number(char checker) -{ - switch(checker) - { - case 'a': - return 0; - case 'c': - return 1; - case 'f': - return 2; - case 'v': - return 3; - case 's': - return 4; - case 'd': - return 5; - case '*': - return 9999; - default: - return -1; - } -} - -// check token based on passed simplified regular expression -BOOL b_check_token(char *token, char *regexp) -{ - S32 tptr, rptr = 0; - S32 current_checker, next_checker = 0; - - current_checker = get_checker_number(regexp[rptr++]); - - if (current_checker == -1) - { - llerrs << "Invalid regular expression value!" << llendl; - return FALSE; - } - - if (current_checker == 9999) - { - llerrs << "Regular expression can't start with *!" << llendl; - return FALSE; - } - - for (tptr = 0; token[tptr]; tptr++) - { - if (current_checker == -1) - { - llerrs << "Input exceeds regular expression!\nDid you forget a *?" << llendl; - return FALSE; - } - - if (!gParseCheckCharacters[current_checker](token[tptr])) - { - return FALSE; - } - if (next_checker != 9999) - { - next_checker = get_checker_number(regexp[rptr++]); - if (next_checker != 9999) - { - current_checker = next_checker; - } - } - } - return TRUE; -} - -// C variable can be made up of upper or lower case letters, underscores, or numbers, but can't start with a number -BOOL b_variable_ok(char *token) -{ - if (!b_check_token(token, "fv*")) - { - llerrs << "Token '" << token << "' isn't a variable!" << llendl; - return FALSE; - } - return TRUE; -} - -// An integer is made up of the digits 0-9 and may be preceded by a '-' -BOOL b_integer_ok(char *token) -{ - if (!b_check_token(token, "sd*")) - { - llerrs << "Token isn't an integer!" << llendl; - return FALSE; - } - return TRUE; -} - -// An integer is made up of the digits 0-9 -BOOL b_positive_integer_ok(char *token) -{ - if (!b_check_token(token, "d*")) - { - llerrs << "Token isn't an integer!" << llendl; - return FALSE; - } - return TRUE; -} - namespace { class LLFnPtrResponder : public LLHTTPClient::Responder { + LOG_CLASS(LLFnPtrResponder); public: - LLFnPtrResponder(void (*callback)(void **,S32), void **callbackData) : + LLFnPtrResponder(void (*callback)(void **,S32), void **callbackData, const std::string& name) : mCallback(callback), - mCallbackData(callbackData) + mCallbackData(callbackData), + mMessageName(name) { } virtual void error(U32 status, const std::string& reason) { + // don't spam when agent communication disconnected already + if (status != 410) + { + llwarns << "error status " << status + << " for message " << mMessageName + << " reason " << reason << llendl; + } // TODO: Map status in to useful error code. if(NULL != mCallback) mCallback(mCallbackData, LL_ERR_TCP_TIMEOUT); } @@ -307,6 +118,7 @@ namespace void (*mCallback)(void **,S32); void **mCallbackData; + std::string mMessageName; }; } @@ -332,10 +144,28 @@ void LLTrustedMessageService::post(LLHTTPNode::ResponsePtr response, ["x-secondlife-udp-listen-port"]; LLSD message_data; - message_data["sender"] = senderIP + ":" + senderPort; + std::string sender = senderIP + ":" + senderPort; + message_data["sender"] = sender; message_data["body"] = input; - LLMessageSystem::dispatch(name, message_data, response); + // untrusted senders should not have access to the trusted message + // service, but this can happen in development, so check and warn + LLMessageConfig::SenderTrust trust = + LLMessageConfig::getSenderTrustedness(name); + if ((trust == LLMessageConfig::TRUSTED || + (trust == LLMessageConfig::NOT_SET && + gMessageSystem->isTrustedMessage(name))) + && !gMessageSystem->isTrustedSender(LLHost(sender))) + { + llwarns << "trusted message POST to /trusted-message/" + << name << " from unknown or untrusted sender " + << sender << llendl; + response->status(403, "Unknown or untrusted sender"); + } + else + { + LLMessageSystem::dispatch(name, message_data, response); + } } class LLMessageHandlerBridge : public LLHTTPNode @@ -352,14 +182,15 @@ void LLMessageHandlerBridge::post(LLHTTPNode::ResponsePtr response, const LLSD& context, const LLSD& input) const { std::string name = context["request"]["wildcard"]["message-name"]; - + char* namePtr = gMessageStringTable.getString(name.c_str()); + lldebugs << "Setting mLastSender " << input["sender"].asString() << llendl; gMessageSystem->mLastSender = LLHost(input["sender"].asString()); gMessageSystem->mPacketsIn += 1; - gMessageSystem->mLLSDMessageReader->setMessage(name, input["body"]); + gMessageSystem->mLLSDMessageReader->setMessage(namePtr, input["body"]); gMessageSystem->mMessageReader = gMessageSystem->mLLSDMessageReader; - if(gMessageSystem->callHandler(name.c_str(), false, gMessageSystem)) + if(gMessageSystem->callHandler(namePtr, false, gMessageSystem)) { response->result(LLSD()); } @@ -381,6 +212,12 @@ LLUseCircuitCodeResponder::~LLUseCircuitCodeResponder() // even abstract base classes need a concrete destructor } +static const char* nullToEmpty(const char* s) +{ + static char emptyString[] = ""; + return s? s : emptyString; +} + void LLMessageSystem::init() { // initialize member variables @@ -420,7 +257,6 @@ void LLMessageSystem::init() mIncomingCompressedSize = 0; mCurrentRecvPacketID = 0; - mMessageFileChecksum = 0; mMessageFileVersionNumber = 0.f; mTimingCallback = NULL; @@ -434,9 +270,7 @@ void LLMessageSystem::init() LLMessageSystem::LLMessageSystem(const char *filename, U32 port, S32 version_major, S32 version_minor, - S32 version_patch) : - mTemplateConfirmed(FALSE), - mTemplateMatches(FALSE) + S32 version_patch) { init(); @@ -509,6 +343,8 @@ LLMessageSystem::LLMessageSystem(const char *filename, U32 port, mTrueReceiveSize = 0; } + + // Read file and build message templates void LLMessageSystem::loadTemplateFile(const char* filename) { @@ -519,797 +355,23 @@ void LLMessageSystem::loadTemplateFile(const char* filename) return; } - char token[MAX_MESSAGE_INTERNAL_NAME_SIZE]; /* Flawfinder: ignore */ - - // state variables - BOOL b_template_start = TRUE; - BOOL b_template_end = FALSE; - BOOL b_template = FALSE; - BOOL b_block_start = FALSE; - BOOL b_block_end = FALSE; - BOOL b_block = FALSE; - BOOL b_variable_start = FALSE; - BOOL b_variable_end = FALSE; - BOOL b_variable = FALSE; - //BOOL b_in_comment_block = FALSE; // not yet used - - // working temp variables - LLMessageTemplate *templatep = NULL; - char template_name[MAX_MESSAGE_INTERNAL_NAME_SIZE]; /* Flawfinder: ignore */ - - LLMessageBlock *blockp = NULL; - char block_name[MAX_MESSAGE_INTERNAL_NAME_SIZE]; /* Flawfinder: ignore */ - - LLMessageVariable var; - char var_name[MAX_MESSAGE_INTERNAL_NAME_SIZE]; /* Flawfinder: ignore */ - char formatString[MAX_MESSAGE_INTERNAL_NAME_SIZE]; /* Flawfinder: ignore */ - - FILE* messagefilep = NULL; - mMessageFileChecksum = 0; - mMessageFileVersionNumber = 0.f; - S32 checksum_offset = 0; - char* checkp = NULL; - - // scanf needs 1 byte more than width, thus the MAX_... -1. - snprintf( /* Flawfinder: ignore */ - formatString, - sizeof(formatString), - "%%%ds", - MAX_MESSAGE_INTERNAL_NAME_SIZE - 1); - messagefilep = LLFile::fopen(filename, "r"); /* Flawfinder: ignore */ - if (messagefilep) - { -// mName = gMessageStringTable.getString(filename); - - fseek(messagefilep, 0L, SEEK_SET ); - while(fscanf(messagefilep, formatString, token) != EOF) /* Flawfinder: ignore */ - { - // skip comments - if (token[0] == '/') - { - // skip to end of line - while (token[0] != 10) - fscanf(messagefilep, "%c", token); - continue; - } - - checkp = token; - - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // what are we looking for - if (!strcmp(token, "{")) - { - // is that a legit option? - if (b_template_start) - { - // yup! - b_template_start = FALSE; - - // remember that it could be only a signal message, so name is all that it contains - b_template_end = TRUE; - - // start working on it! - b_template = TRUE; - } - else if (b_block_start) - { - // yup! - b_block_start = FALSE; - b_template_end = FALSE; - - // start working on it! - b_block = TRUE; - } - else if (b_variable_start) - { - // yup! - b_variable_start = FALSE; - b_block_end = FALSE; - - // start working on it! - b_variable = TRUE; - } - else - { - llerrs << "Detcted unexpected token '" << token - << "' while parsing template." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - } - - if (!strcmp(token, "}")) - { - // is that a legit option? - if (b_template_end) - { - // yup! - b_template_end = FALSE; - b_template = FALSE; - b_block_start = FALSE; - - // add data! - // we've gotten a complete variable! hooray! - // add it! - if (NULL == templatep) - { - llerrs << "Trying to addTemplate a NULL templatep during load." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - addTemplate(templatep); - - //llinfos << "Read template: "templatep->mNametemp_str - // << llendl; - - // look for next one! - b_template_start = TRUE; - } - else if (b_block_end) - { - // yup! - b_block_end = FALSE; - b_variable_start = FALSE; - - // add data! - // we've gotten a complete variable! hooray! - // add it to template - if (NULL == templatep) - { - llerrs << "Trying to addBlock to NULL templatep during load." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - templatep->addBlock(blockp); - - // start working on it! - b_template_end = TRUE; - b_block_start = TRUE; - } - else if (b_variable_end) - { - // yup! - b_variable_end = FALSE; - - // add data! - // we've gotten a complete variable! hooray! - // add it to block - blockp->addVariable(var.getName(), var.getType(), var.getSize()); - - // start working on it! - b_variable_start = TRUE; - b_block_end = TRUE; - } - else - { - llerrs << "Detcted unexpected token '" << token - << "' while parsing template." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - } - - // now, are we looking to start a template? - if (b_template) - { - - b_template = FALSE; - - // name first - if (fscanf(messagefilep, formatString, template_name) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected message template name, but file ended" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - // debugging to help figure out busted templates - //llinfos << template_name << llendl; - - // is name a legit C variable name - if (!b_variable_ok(template_name)) - { - // nope! - llerrs << "Not legal message template name: " - << template_name << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = template_name; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // ok, now get Frequency ("High", "Medium", or "Low") - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected message template frequency, found EOF." - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // which one is it? - if (!strcmp(token, "High")) - { - if (++mNumberHighFreqMessages == 255) - { - // oops, too many High Frequency messages!! - llerrs << "Message " << template_name - << " exceeded 254 High frequency messages!" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - // ok, we can create a template! - // message number is just mNumberHighFreqMessages - templatep = new LLMessageTemplate(template_name, mNumberHighFreqMessages, MFT_HIGH); - //lldebugs << "Template " << template_name << " # " - // << std::hex << mNumberHighFreqMessages - // << std::dec << " high" - // << llendl; - } - else if (!strcmp(token, "Medium")) - { - if (++mNumberMediumFreqMessages == 255) - { - // oops, too many Medium Frequency messages!! - llerrs << "Message " << template_name - << " exceeded 254 Medium frequency messages!" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - // ok, we can create a template! - // message number is ((255 << 8) | mNumberMediumFreqMessages) - templatep = new LLMessageTemplate(template_name, (255 << 8) | mNumberMediumFreqMessages, MFT_MEDIUM); - //lldebugs << "Template " << template_name << " # " - // << std::hex << mNumberMediumFreqMessages - // << std::dec << " medium" - // << llendl; - } - else if (!strcmp(token, "Low")) - { - if (++mNumberLowFreqMessages == 65535) - { - // oops, too many High Frequency messages!! - llerrs << "Message " << template_name - << " exceeded 65534 Low frequency messages!" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - // ok, we can create a template! - // message number is ((255 << 24) | (255 << 16) | mNumberLowFreqMessages) - templatep = new LLMessageTemplate(template_name, (255 << 24) | (255 << 16) | mNumberLowFreqMessages, MFT_LOW); - //lldebugs << "Template " << template_name << " # " - // << std::hex << mNumberLowFreqMessages - // << std::dec << " low" - // << llendl; - } - else if (!strcmp(token, "Fixed")) - { - U32 message_num = 0; - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected message template number (fixed)," - << " found EOF." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - message_num = strtoul(token,NULL,0); - - // ok, we can create a template! - // message number is ((255 << 24) | (255 << 16) | mNumberLowFreqMessages) - templatep = new LLMessageTemplate(template_name, message_num, MFT_LOW); - } - else - { - // oops, bad frequency line - llerrs << "Bad frequency! " << token - << " isn't High, Medium, or Low" << llendl - mbError = TRUE; - fclose(messagefilep); - return; - } - - // Now get trust ("Trusted", "NotTrusted") - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // File ended - llerrs << "Expected message template " - "trust, but file ended." - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32) *checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - if (strcmp(token, "Trusted") == 0) - { - if (NULL == templatep) - { - llerrs << "Trying to setTrust for NULL templatep during load." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - templatep->setTrust(MT_TRUST); - } - else if (strcmp(token, "NotTrusted") == 0) - { - if (NULL == templatep) - { - llerrs << "Trying to setTrust for NULL templatep during load." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - templatep->setTrust(MT_NOTRUST); - } - else - { - // bad trust token - llerrs << "bad trust: " << token - << " isn't Trusted or NotTrusted" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - // get encoding - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // File ended - llerrs << "Expected message encoding, but file ended." - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - checkp = token; - while(*checkp) - { - mMessageFileChecksum += ((U32) *checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - if(0 == strcmp(token, "Unencoded")) - { - if (NULL == templatep) - { - llerrs << "Trying to setEncoding for NULL templatep during load." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - templatep->setEncoding(ME_UNENCODED); - } - else if(0 == strcmp(token, "Zerocoded")) - { - if (NULL == templatep) - { - llerrs << "Trying to setEncoding for NULL templatep during load." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - templatep->setEncoding(ME_ZEROCODED); - } - else - { - // bad trust token - llerrs << "bad encoding: " << token - << " isn't Unencoded or Zerocoded" << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - // ok, now we need to look for a block - b_block_start = TRUE; - continue; - } - - // now, are we looking to start a template? - if (b_block) - { - b_block = FALSE; - // ok, need to pull header info - - // name first - if (fscanf(messagefilep, formatString, block_name) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected block name, but file ended" << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = block_name; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // is name a legit C variable name - if (!b_variable_ok(block_name)) - { - // nope! - llerrs << block_name << "is not a legal block name" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - // now, block type ("Single", "Multiple", or "Variable") - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected block type, but file ended." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // which one is it? - if (!strcmp(token, "Single")) - { - // ok, we can create a block - blockp = new LLMessageBlock(block_name, MBT_SINGLE); - } - else if (!strcmp(token, "Multiple")) - { - // need to get the number of repeats - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected block multiple count," - " but file ended." << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // is it a legal integer - if (!b_positive_integer_ok(token)) - { - // nope! - llerrs << token << "is not a legal integer for" - " block multiple count" << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - // ok, we can create a block - blockp = new LLMessageBlock(block_name, MBT_MULTIPLE, atoi(token)); - } - else if (!strcmp(token, "Variable")) - { - // ok, we can create a block - blockp = new LLMessageBlock(block_name, MBT_VARIABLE); - } - else - { - // oops, bad block type - llerrs << "Bad block type! " << token - << " isn't Single, Multiple, or Variable" << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - // ok, now we need to look for a variable - b_variable_start = TRUE; - continue; - } - - // now, are we looking to start a template? - if (b_variable) - { - b_variable = FALSE; - // ok, need to pull header info - - // name first - if (fscanf(messagefilep, formatString, var_name) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected variable name, but file ended." - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = var_name; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // is name a legit C variable name - if (!b_variable_ok(var_name)) - { - // nope! - llerrs << var_name << " is not a legal variable name" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - // now, variable type ("Fixed" or "Variable") - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected variable type, but file ended" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - - // which one is it? - if (!strcmp(token, "U8")) - { - var = LLMessageVariable(var_name, MVT_U8, 1); - } - else if (!strcmp(token, "U16")) - { - var = LLMessageVariable(var_name, MVT_U16, 2); - } - else if (!strcmp(token, "U32")) - { - var = LLMessageVariable(var_name, MVT_U32, 4); - } - else if (!strcmp(token, "U64")) - { - var = LLMessageVariable(var_name, MVT_U64, 8); - } - else if (!strcmp(token, "S8")) - { - var = LLMessageVariable(var_name, MVT_S8, 1); - } - else if (!strcmp(token, "S16")) - { - var = LLMessageVariable(var_name, MVT_S16, 2); - } - else if (!strcmp(token, "S32")) - { - var = LLMessageVariable(var_name, MVT_S32, 4); - } - else if (!strcmp(token, "S64")) - { - var = LLMessageVariable(var_name, MVT_S64, 8); - } - else if (!strcmp(token, "F32")) - { - var = LLMessageVariable(var_name, MVT_F32, 4); - } - else if (!strcmp(token, "F64")) - { - var = LLMessageVariable(var_name, MVT_F64, 8); - } - else if (!strcmp(token, "LLVector3")) - { - var = LLMessageVariable(var_name, MVT_LLVector3, 12); - } - else if (!strcmp(token, "LLVector3d")) - { - var = LLMessageVariable(var_name, MVT_LLVector3d, 24); - } - else if (!strcmp(token, "LLVector4")) - { - var = LLMessageVariable(var_name, MVT_LLVector4, 16); - } - else if (!strcmp(token, "LLQuaternion")) - { - var = LLMessageVariable(var_name, MVT_LLQuaternion, 12); - } - else if (!strcmp(token, "LLUUID")) - { - var = LLMessageVariable(var_name, MVT_LLUUID, 16); - } - else if (!strcmp(token, "BOOL")) - { - var = LLMessageVariable(var_name, MVT_BOOL, 1); - } - else if (!strcmp(token, "IPADDR")) - { - var = LLMessageVariable(var_name, MVT_IP_ADDR, 4); - } - else if (!strcmp(token, "IPPORT")) - { - var = LLMessageVariable(var_name, MVT_IP_PORT, 2); - } - else if (!strcmp(token, "Fixed")) - { - // need to get the variable size - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected variable size, but file ended" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // is it a legal integer - if (!b_positive_integer_ok(token)) - { - // nope! - llerrs << token << " is not a legal integer for" - " variable size" << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - // ok, we can create a block - var = LLMessageVariable(var_name, MVT_FIXED, atoi(token)); - } - else if (!strcmp(token, "Variable")) - { - // need to get the variable size - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected variable size, but file ended" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - // is it a legal integer - if (!b_positive_integer_ok(token)) - { - // nope! - llerrs << token << "is not a legal integer" - " for variable size" << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - // ok, we can create a block - var = LLMessageVariable(var_name, MVT_VARIABLE, atoi(token)); - } - else - { - // oops, bad variable type - llerrs << "Bad variable type! " << token - << " isn't Fixed or Variable" << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - // we got us a variable! - b_variable_end = TRUE; - continue; - } - - // do we have a version number stuck in the file? - if (!strcmp(token, "version")) - { - // version number - if (fscanf(messagefilep, formatString, token) == EOF) /* Flawfinder: ignore */ - { - // oops, file ended - llerrs << "Expected version number, but file ended" - << llendl; - mbError = TRUE; - fclose(messagefilep); - return; - } - - checkp = token; - while (*checkp) - { - mMessageFileChecksum += ((U32)*checkp++) << checksum_offset; - checksum_offset = (checksum_offset + 8) % 32; - } - - mMessageFileVersionNumber = (F32)atof(token); - -// llinfos << "### Message template version " << mMessageFileVersionNumber << " ###" << llendl; - continue; - } - } - - llinfos << "Message template checksum = " << std::hex << mMessageFileChecksum << std::dec << llendl; - } - else + LLString template_body; + if(!LLString::read(template_body, filename)) { llwarns << "Failed to open template: " << filename << llendl; mbError = TRUE; return; } - fclose(messagefilep); + + LLTemplateTokenizer tokens(template_body); + LLTemplateParser parsed(tokens); + mMessageFileVersionNumber = parsed.getVersion(); + for(LLTemplateParser::message_iterator iter = parsed.getMessagesBegin(); + iter != parsed.getMessagesEnd(); + iter++) + { + addTemplate(*iter); + } } @@ -1373,6 +435,94 @@ BOOL LLMessageSystem::poll(F32 seconds) } } +bool LLMessageSystem::isTrustedSender(const LLHost& host) const +{ + LLCircuitData* cdp = mCircuitInfo.findCircuit(host); + if(NULL == cdp) + { + return false; + } + return cdp->getTrusted(); +} + +static LLMessageSystem::message_template_name_map_t::const_iterator +findTemplate(const LLMessageSystem::message_template_name_map_t& templates, + std::string name) +{ + const char* namePrehash = gMessageStringTable.getString(name.c_str()); + if(NULL == namePrehash) {return templates.end();} + return templates.find(namePrehash); +} + +bool LLMessageSystem::isTrustedMessage(const std::string& name) const +{ + message_template_name_map_t::const_iterator iter = + findTemplate(mMessageTemplates, name); + if(iter == mMessageTemplates.end()) {return false;} + return iter->second->getTrust() == MT_TRUST; +} + +bool LLMessageSystem::isUntrustedMessage(const std::string& name) const +{ + message_template_name_map_t::const_iterator iter = + findTemplate(mMessageTemplates, name); + if(iter == mMessageTemplates.end()) {return false;} + return iter->second->getTrust() == MT_NOTRUST; +} + +LLCircuitData* LLMessageSystem::findCircuit(const LLHost& host, + bool resetPacketId) +{ + LLCircuitData* cdp = mCircuitInfo.findCircuit(host); + if (!cdp) + { + // This packet comes from a circuit we don't know about. + + // Are we rejecting off-circuit packets? + if (mbProtected) + { + // cdp is already NULL, so we don't need to unset it. + } + else + { + // nope, open the new circuit + cdp = mCircuitInfo.addCircuitData(host, mCurrentRecvPacketID); + + if(resetPacketId) + { + // I added this - I think it's correct - DJS + // reset packet in ID + cdp->setPacketInID(mCurrentRecvPacketID); + } + // And claim the packet is on the circuit we just added. + } + } + else + { + // this is an old circuit. . . is it still alive? + if (!cdp->isAlive()) + { + // nope. don't accept if we're protected + if (mbProtected) + { + // don't accept packets from unexpected sources + cdp = NULL; + } + else + { + // wake up the circuit + cdp->setAlive(TRUE); + + if(resetPacketId) + { + // reset packet in ID + cdp->setPacketInID(mCurrentRecvPacketID); + } + } + } + } + return cdp; +} // Returns TRUE if a valid, on-circuit message has been received. BOOL LLMessageSystem::checkMessages( S64 frame_count ) @@ -1451,71 +601,12 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count ) } // process the message as normal - - mIncomingCompressedSize = zeroCodeExpand(&buffer,&receive_size); - mCurrentRecvPacketID = buffer[1] + ((buffer[0] & 0x0f ) * 256); - if (sizeof(TPACKETID) == 4) - { - mCurrentRecvPacketID *= 256; - mCurrentRecvPacketID += buffer[2]; - mCurrentRecvPacketID *= 256; - mCurrentRecvPacketID += buffer[3]; - } - + mIncomingCompressedSize = zeroCodeExpand(&buffer, &receive_size); + mCurrentRecvPacketID = ntohl(*((U32*)(&buffer[1]))); host = getSender(); - //llinfos << host << ":" << mCurrentRecvPacketID << llendl; - // For testing the weird case we're having in the office where the first few packets - // on a connection get dropped - //if ((mCurrentRecvPacketID < 8) && !(buffer[0] & LL_RESENT_FLAG)) - //{ - // llinfos << "Evil! Dropping " << mCurrentRecvPacketID << " from " << host << " for fun!" << llendl; - // continue; - //} - - cdp = mCircuitInfo.findCircuit(host); - if (!cdp) - { - // This packet comes from a circuit we don't know about. - - // Are we rejecting off-circuit packets? - if (mbProtected) - { - // cdp is already NULL, so we don't need to unset it. - } - else - { - // nope, open the new circuit - cdp = mCircuitInfo.addCircuitData(host, mCurrentRecvPacketID); - - // I added this - I think it's correct - DJS - // reset packet in ID - cdp->setPacketInID(mCurrentRecvPacketID); - - // And claim the packet is on the circuit we just added. - } - } - else - { - // this is an old circuit. . . is it still alive? - if (!cdp->isAlive()) - { - // nope. don't accept if we're protected - if (mbProtected) - { - // don't accept packets from unexpected sources - cdp = NULL; - } - else - { - // wake up the circuit - cdp->setAlive(TRUE); - - // reset packet in ID - cdp->setPacketInID(mCurrentRecvPacketID); - } - } - } + const bool resetPacketId = true; + cdp = findCircuit(host, resetPacketId); // At this point, cdp is now a pointer to the circuit that // this message came in on if it's valid, and NULL if the @@ -1644,6 +735,10 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count ) if (valid_packet) { + // enable this for output of message names + //llinfos << "< \"" << mTemplateMessageReader->getMessageName() + //<< "\"" << llendl; + /* Code for dumping the complete contents of a message. Keep for future use in optimizing messages. if( 1 ) { @@ -1748,9 +843,7 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count ) { if (mbProtected && (!cdp)) { - llwarns << "Packet " - << mTemplateMessageReader->getMessageName() - << " from invalid circuit " << host << llendl; + llwarns << "Invalid Packet from invalid circuit " << host << llendl; mOffCircuitPackets++; } else @@ -2031,15 +1124,34 @@ S32 LLMessageSystem::flushReliable(const LLHost &host) return send_bytes; } - +LLHTTPClient::ResponderPtr LLMessageSystem::createResponder(const std::string& name) +{ + if(mSendReliable) + { + return new LLFnPtrResponder(mReliablePacketParams.mCallback, + mReliablePacketParams.mCallbackData, + name); + } + else + { + llwarns << "LLMessageSystem::sendMessage: Sending unreliable " + << mMessageBuilder->getMessageName() << " message via HTTP" + << llendl; + return new LLFnPtrResponder(NULL, NULL, + mMessageBuilder->getMessageName()); + } +} + // This can be called from signal handlers, // so should should not use llinfos. S32 LLMessageSystem::sendMessage(const LLHost &host) { if (! mMessageBuilder->isBuilt()) { - mSendSize = mMessageBuilder->buildMessage(mSendBuffer, - MAX_BUFFER_SIZE); + mSendSize = mMessageBuilder->buildMessage( + mSendBuffer, + MAX_BUFFER_SIZE, + 0); } if (!(host.isOk())) // if port and ip are zero, don't bother trying to send the message @@ -2068,6 +1180,7 @@ S32 LLMessageSystem::sendMessage(const LLHost &host) else { // nope, open the new circuit + cdp = mCircuitInfo.addCircuitData(host, 0); } } @@ -2095,33 +1208,23 @@ S32 LLMessageSystem::sendMessage(const LLHost &host) LLSD message = mLLSDMessageBuilder->getMessage(); const LLHTTPSender& sender = LLHTTPSender::getSender(host); - LLHTTPClient::ResponderPtr responder = NULL; - if(mSendReliable) - { - responder = - new LLFnPtrResponder(mReliablePacketParams.mCallback, - mReliablePacketParams.mCallbackData); - } - else - { - llwarns << "LLMessageSystem::sendMessage: Sending unreliable " << mMessageBuilder->getMessageName() << " message via HTTP" << llendl; - responder = new LLFnPtrResponder(NULL, NULL); - } sender.send(host, mLLSDMessageBuilder->getMessageName(), - message, responder); + message, createResponder(mLLSDMessageBuilder->getMessageName())); mSendReliable = FALSE; mReliablePacketParams.clear(); return 1; } - memset(mSendBuffer,0,LL_PACKET_ID_SIZE); // zero out the packet ID field + // zero out the flags and packetid. Subtract 1 here so that we do + // not overwrite the offset if it was set set in buildMessage(). + memset(mSendBuffer, 0, LL_PACKET_ID_SIZE - 1); // add the send id to the front of the message cdp->nextPacketOutID(); // Packet ID size is always 4 - *((S32*)&mSendBuffer[0]) = htonl(cdp->getPacketOutID()); + *((S32*)&mSendBuffer[PHL_PACKET_ID]) = htonl(cdp->getPacketOutID()); // Compress the message, which will usually reduce its size. U8 * buf_ptr = (U8 *)mSendBuffer; @@ -2264,7 +1367,7 @@ void LLMessageSystem::logMsgFromInvalidCircuit( const LLHost& host, BOOL recv_re char buffer[MAX_STRING]; /* Flawfinder: ignore */ snprintf(buffer, MAX_STRING, "\t%6d\t%6d\t%6d ", mMessageReader->getMessageSize(), (mIncomingCompressedSize ? mIncomingCompressedSize: mMessageReader->getMessageSize()), mCurrentRecvPacketID); /* Flawfinder: ignore */ str << buffer - << mMessageReader->getMessageName() + << nullToEmpty(mMessageReader->getMessageName()) << (recv_reliable ? " reliable" : "") << " REJECTED"; llinfos << str.str() << llendl; @@ -2287,6 +1390,27 @@ void LLMessageSystem::logMsgFromInvalidCircuit( const LLHost& host, BOOL recv_re } } +S32 LLMessageSystem::sendMessage(const LLHost &host, const char* name, + const LLSD& message) +{ + if (!(host.isOk())) + { + llwarns << "trying to send message to invalid host" << llendl; + return 0; + } + newMessage(name); + if (mMessageBuilder != mLLSDMessageBuilder) + { + llwarns << "trying to send llsd message when builder is not LLSD!" + << llendl; + return 0; + } + + const LLHTTPSender& sender = LLHTTPSender::getSender(host); + sender.send(host, name, message, createResponder(name)); + return 1; +} + void LLMessageSystem::logTrustedMsgFromUntrustedCircuit( const LLHost& host ) { // RequestTrustedCircuit is how we establish trust, so don't spam @@ -2294,9 +1418,9 @@ void LLMessageSystem::logTrustedMsgFromUntrustedCircuit( const LLHost& host ) if (strcmp(mMessageReader->getMessageName(), "RequestTrustedCircuit")) { llwarns << "Received trusted message on untrusted circuit. " - << "Will reply with deny. " - << "Message: " << mMessageReader->getMessageName() - << " Host: " << host << llendl; + << "Will reply with deny. " + << "Message: " << nullToEmpty(mMessageReader->getMessageName()) + << " Host: " << host << llendl; } if (mNumMessageCounts >= MAX_MESSAGE_COUNT_NUM) @@ -2346,7 +1470,7 @@ void LLMessageSystem::logValidMsg(LLCircuitData *cdp, const LLHost& host, BOOL r char buffer[MAX_STRING]; /* Flawfinder: ignore */ snprintf(buffer, MAX_STRING, "\t%6d\t%6d\t%6d ", mMessageReader->getMessageSize(), (mIncomingCompressedSize ? mIncomingCompressedSize : mMessageReader->getMessageSize()), mCurrentRecvPacketID); /* Flawfinder: ignore */ str << buffer - << mMessageReader->getMessageName() + << nullToEmpty(mMessageReader->getMessageName()) << (recv_reliable ? " reliable" : "") << (recv_resent ? " resent" : "") << (recv_acks ? " acks" : ""); @@ -2486,16 +1610,16 @@ void LLMessageSystem::disableCircuit(const LLHost &host) llinfos << "Host " << LLHost(old_ip, old_port) << " circuit " << code << " removed from lookup table" << llendl; gMessageSystem->mIPPortToCircuitCode.erase(ip_port); } + mCircuitInfo.removeCircuitData(host); } else { // Sigh, since we can open circuits which don't have circuit // codes, it's possible for this to happen... - //llwarns << "Couldn't find circuit code for " << host << llendl; + llwarns << "Couldn't find circuit code for " << host << llendl; } - mCircuitInfo.removeCircuitData(host); } @@ -2917,6 +2041,30 @@ void LLMessageSystem::processUseCircuitCode(LLMessageSystem* msg, } } +// static +void LLMessageSystem::processError(LLMessageSystem* msg, void**) +{ + char buffer[MTUBYTES]; + S32 error_code = 0; + msg->getS32("Data", "Code", error_code); + std::string error_token; + msg->getString("Data", "Token", MTUBYTES, buffer); + error_token.assign(buffer); + LLUUID error_id; + msg->getUUID("Data", "ID", error_id); + std::string error_system; + msg->getString("Data", "System", MTUBYTES, buffer); + error_system.assign(buffer); + std::string error_message; + msg->getString("Data", "Message", MTUBYTES, buffer); + error_message.assign(buffer); + + llwarns << "Message error from " << msg->getSender() << " - " + << error_code << " " << error_token << " " << error_id << " \"" + << error_system << "\" \"" << error_message << "\"" << llendl; +} + + static LLHTTPNode& messageRootNode() { static LLHTTPNode root_node; @@ -2944,10 +2092,13 @@ void LLMessageSystem::dispatch( const LLSD& message, LLHTTPNode::ResponsePtr responsep) { - if (msg_name.empty()) + if ((gMessageSystem->mMessageTemplates.find + (gMessageStringTable.getString(msg_name.c_str())) == + gMessageSystem->mMessageTemplates.end()) && + !LLMessageConfig::isValidMessage(msg_name)) { - llwarns << "LLMessageService::dispatch called with no message name" - << llendl; + llwarns << "Ignoring unknown message " << msg_name << llendl; + responsep->notFound("Invalid message name"); return; } @@ -2960,6 +2111,9 @@ void LLMessageSystem::dispatch( << path << llendl; return; } + // enable this for output of message names + //llinfos << "< \"" << msg_name << "\"" << llendl; + //lldebugs << "data: " << LLSDXMLStreamer(message) << llendl; handler->post(responsep, context, message); } @@ -3024,6 +2178,56 @@ void LLMessageSystem::setMessageBans( check_for_unrecognized_messages("untrusted", untrusted, mMessageTemplates); } +S32 LLMessageSystem::sendError( + const LLHost& host, + const LLUUID& agent_id, + S32 code, + const std::string& token, + const LLUUID& id, + const std::string& system, + const std::string& message, + const LLSD& data) +{ + newMessage("Error"); + nextBlockFast(_PREHASH_AgentData); + addUUIDFast(_PREHASH_AgentID, agent_id); + nextBlockFast(_PREHASH_Data); + addS32("Code", code); + addString("Token", token); + addUUID("ID", id); + addString("System", system); + std::string temp; + temp = message; + if(temp.size() > (size_t)MTUBYTES) temp.resize((size_t)MTUBYTES); + addString("Message", message); + LLPointer<LLSDBinaryFormatter> formatter = new LLSDBinaryFormatter; + std::ostringstream ostr; + formatter->format(data, ostr); + temp = ostr.str(); + bool pack_data = true; + static const std::string ERROR_MESSAGE_NAME("Error"); + if (LLMessageConfig::getMessageFlavor(ERROR_MESSAGE_NAME) == + LLMessageConfig::TEMPLATE_FLAVOR) + { + S32 msg_size = temp.size() + mMessageBuilder->getMessageSize(); + if(msg_size >= ETHERNET_MTU_BYTES) + { + pack_data = false; + } + } + if(pack_data) + { + addBinaryData("Data", (void*)temp.c_str(), temp.size()); + } + else + { + llwarns << "Data and message were too large -- data removed." + << llendl; + addBinaryData("Data", NULL, 0); + } + return sendReliable(host); +} + void process_packet_ack(LLMessageSystem *msgsystem, void** /*user_data*/) { TPACKETID packet_id; @@ -3049,37 +2253,8 @@ void process_packet_ack(LLMessageSystem *msgsystem, void** /*user_data*/) } } -void send_template_reply(LLMessageSystem* msg, const LLUUID& token) -{ - msg->newMessageFast(_PREHASH_TemplateChecksumReply); - msg->nextBlockFast(_PREHASH_DataBlock); - msg->addU32Fast(_PREHASH_Checksum, msg->mMessageFileChecksum); - msg->addU8Fast(_PREHASH_MajorVersion, U8(msg->mSystemVersionMajor) ); - msg->addU8Fast(_PREHASH_MinorVersion, U8(msg->mSystemVersionMinor) ); - msg->addU8Fast(_PREHASH_PatchVersion, U8(msg->mSystemVersionPatch) ); - msg->addU8Fast(_PREHASH_ServerVersion, U8(msg->mSystemVersionServer) ); - msg->addU32Fast(_PREHASH_Flags, msg->mVersionFlags); - msg->nextBlockFast(_PREHASH_TokenBlock); - msg->addUUIDFast(_PREHASH_Token, token); - msg->sendMessage(msg->getSender()); -} - -void process_template_checksum_request(LLMessageSystem* msg, void**) -{ - llinfos << "Message template checksum request received from " - << msg->getSender() << llendl; - send_template_reply(msg, LLUUID::null); -} - -void process_secured_template_checksum_request(LLMessageSystem* msg, void**) -{ - llinfos << "Secured message template checksum request received from " - << msg->getSender() << llendl; - LLUUID token; - msg->getUUIDFast(_PREHASH_TokenBlock, _PREHASH_Token, token); - send_template_reply(msg, token); -} +/* void process_log_messages(LLMessageSystem* msg, void**) { U8 log_message; @@ -3096,7 +2271,7 @@ void process_log_messages(LLMessageSystem* msg, void**) llinfos << "Stopping logging via message" << llendl; msg->stopLogging(); } -} +}*/ // Make circuit trusted if the MD5 Digest matches, otherwise // notify remote end that they are not trusted. @@ -3329,15 +2504,14 @@ BOOL start_messaging_system( //gMessageSystem->setHandlerFuncFast(_PREHASH_AckAddCircuitCode, ack_add_circuit_code, NULL); gMessageSystem->setHandlerFuncFast(_PREHASH_UseCircuitCode, LLMessageSystem::processUseCircuitCode, (void**)responder); gMessageSystem->setHandlerFuncFast(_PREHASH_PacketAck, process_packet_ack, NULL); - gMessageSystem->setHandlerFuncFast(_PREHASH_TemplateChecksumRequest, process_template_checksum_request, NULL); - gMessageSystem->setHandlerFuncFast(_PREHASH_SecuredTemplateChecksumRequest, process_secured_template_checksum_request, NULL); - gMessageSystem->setHandlerFuncFast(_PREHASH_LogMessages, process_log_messages, NULL); + //gMessageSystem->setHandlerFuncFast(_PREHASH_LogMessages, process_log_messages, NULL); gMessageSystem->setHandlerFuncFast(_PREHASH_CreateTrustedCircuit, process_create_trusted_circuit, NULL); gMessageSystem->setHandlerFuncFast(_PREHASH_DenyTrustedCircuit, process_deny_trusted_circuit, NULL); + gMessageSystem->setHandlerFunc("Error", LLMessageSystem::processError); // We can hand this to the null_message_callback since it is a // trusted message, so it will automatically be denied if it isn't @@ -3451,11 +2625,11 @@ void LLMessageSystem::summarizeLogs(std::ostream& str) snprintf(buffer, MAX_STRING, "%35s%10s%10s%10s%10s", "Message", "Count", "Time", "Max", "Avg"); /* Flawfinder: ignore */ str << buffer << std:: endl; F32 avg; - for (message_template_name_map_t::iterator iter = mMessageTemplates.begin(), + for (message_template_name_map_t::const_iterator iter = mMessageTemplates.begin(), end = mMessageTemplates.end(); iter != end; iter++) { - LLMessageTemplate* mt = iter->second; + const LLMessageTemplate* mt = iter->second; if(mt->mTotalDecoded > 0) { avg = mt->mTotalDecodeTime / (F32)mt->mTotalDecoded; @@ -3529,11 +2703,11 @@ void LLMessageSystem::dumpReceiveCounts() if(mNumMessageCounts > 0) { llinfos << "Dump: " << mNumMessageCounts << " messages processed in " << mReceiveTime << " seconds" << llendl; - for (message_template_name_map_t::iterator iter = mMessageTemplates.begin(), + for (message_template_name_map_t::const_iterator iter = mMessageTemplates.begin(), end = mMessageTemplates.end(); iter != end; iter++) { - LLMessageTemplate* mt = iter->second; + const LLMessageTemplate* mt = iter->second; if (mt->mReceiveCount > 0) { llinfos << "Num: " << std::setw(3) << mt->mReceiveCount << " Bytes: " << std::setw(6) << mt->mReceiveBytes @@ -3581,8 +2755,10 @@ S32 LLMessageSystem::zeroCodeAdjustCurrentSendTotal() if (! mMessageBuilder->isBuilt()) { - mSendSize = mMessageBuilder->buildMessage(mSendBuffer, - MAX_BUFFER_SIZE); + mSendSize = mMessageBuilder->buildMessage( + mSendBuffer, + MAX_BUFFER_SIZE, + 0); } // TODO: babbage: remove this horror mMessageBuilder->setBuilt(FALSE); @@ -3596,7 +2772,7 @@ S32 LLMessageSystem::zeroCodeAdjustCurrentSendTotal() // skip the packet id field - for (U32 i=0;i<LL_PACKET_ID_SIZE;i++) + for (U32 ii = 0; ii < LL_PACKET_ID_SIZE; ++ii) { count--; inptr++; @@ -3647,19 +2823,20 @@ S32 LLMessageSystem::zeroCodeAdjustCurrentSendTotal() -S32 LLMessageSystem::zeroCodeExpand(U8 **data, S32 *data_size) +S32 LLMessageSystem::zeroCodeExpand(U8** data, S32* data_size) { - - if ((*data_size ) < LL_PACKET_ID_SIZE) + if ((*data_size ) < LL_MINIMUM_VALID_PACKET_SIZE) { - llwarns << "zeroCodeExpand() called with data_size of " << *data_size << llendl; + llwarns << "zeroCodeExpand() called with data_size of " << *data_size + << llendl; } - + mTotalBytesIn += *data_size; - if (!(*data[0] & LL_ZERO_CODE_FLAG)) // if we're not zero-coded, just go 'way + // if we're not zero-coded, simply return. + if (!(*data[0] & LL_ZERO_CODE_FLAG)) { - return(0); + return 0; } S32 in_size = *data_size; @@ -3675,7 +2852,7 @@ S32 LLMessageSystem::zeroCodeExpand(U8 **data, S32 *data_size) // skip the packet id field - for (U32 i=0;i<LL_PACKET_ID_SIZE;i++) + for (U32 ii = 0; ii < LL_PACKET_ID_SIZE; ++ii) { count--; *outptr++ = *inptr++; @@ -3769,14 +2946,16 @@ bool LLMessageSystem::callHandler(const char *name, bool trustedSource, LLMessageSystem* msg) { name = gMessageStringTable.getString(name); - LLMessageTemplate* msg_template = mMessageTemplates[(char*)name]; - if (!msg_template) + message_template_name_map_t::const_iterator iter; + iter = mMessageTemplates.find(name); + if(iter == mMessageTemplates.end()) { llwarns << "LLMessageSystem::callHandler: unknown message " << name << llendl; return false; } - + + const LLMessageTemplate* msg_template = iter->second; if (msg_template->isBanned(trustedSource)) { llwarns << "LLMessageSystem::callHandler: banned message " @@ -3832,14 +3011,13 @@ BOOL LLMessageSystem::isCircuitCodeKnown(U32 code) const BOOL LLMessageSystem::isMessageFast(const char *msg) { - return(msg == mMessageReader->getMessageName()); + return msg == mMessageReader->getMessageName(); } char* LLMessageSystem::getMessageName() { - const char* name = mMessageReader->getMessageName(); - return name[0] == '\0'? NULL : const_cast<char*>(name); + return const_cast<char*>(mMessageReader->getMessageName()); } const LLUUID& LLMessageSystem::getSenderID() const @@ -4168,120 +3346,6 @@ void LLMessageSystem::dumpPacketToLog() } } -//static -BOOL LLMessageSystem::isTemplateConfirmed() -{ - return gMessageSystem->mTemplateConfirmed; -} - -//static -BOOL LLMessageSystem::doesTemplateMatch() -{ - if (!isTemplateConfirmed()) - { - return FALSE; - } - return gMessageSystem->mTemplateMatches; -} - -//static -void LLMessageSystem::sendMessageTemplateChecksum(const LLHost ¤tHost) -{ - gMessageSystem->mTemplateConfirmed = FALSE; - gMessageSystem->mTemplateMatches = FALSE; - gMessageSystem->newMessageFast(_PREHASH_TemplateChecksumRequest); - // Don't use ping-based retry - gMessageSystem->sendReliable(currentHost, 40, FALSE, 3, NULL, NULL); -} - -//static -void LLMessageSystem::processMessageTemplateChecksumReply(LLMessageSystem *msg, - void** user_data) -{ - U32 remote_template_checksum = 0; - msg->getU32Fast(_PREHASH_DataBlock, _PREHASH_Checksum, remote_template_checksum); - msg->mTemplateConfirmed = TRUE; - if ((remote_template_checksum) != msg->mMessageFileChecksum) - { - llwarns << "out of sync message template!" << llendl; - - msg->mTemplateMatches = FALSE; - msg->newMessageFast(_PREHASH_CloseCircuit); - msg->sendMessage(msg->getSender()); - return; - } - - msg->mTemplateMatches = TRUE; - llinfos << "According to " << msg->getSender() - << " the message template is current!" - << llendl; -} - -//static -void LLMessageSystem::sendSecureMessageTemplateChecksum(const LLHost& host) -{ - // generate an token for use during template checksum requests to - // prevent DOS attacks from injected bad template checksum replies. - LLUUID *template_tokenp = new LLUUID; - template_tokenp->generate(); - lldebugs << "random token: " << *template_tokenp << llendl; - - // register the handler for the reply while saving off template_token - gMessageSystem->setHandlerFuncFast(_PREHASH_TemplateChecksumReply, - LLMessageSystem::processSecureTemplateChecksumReply, - (void**)template_tokenp); - - // send checksum request - gMessageSystem->mTemplateConfirmed = FALSE; - gMessageSystem->newMessageFast(_PREHASH_SecuredTemplateChecksumRequest); - gMessageSystem->nextBlockFast(_PREHASH_TokenBlock); - gMessageSystem->addUUIDFast(_PREHASH_Token, *template_tokenp); - gMessageSystem->sendReliable(host); -} - -//static -void LLMessageSystem::processSecureTemplateChecksumReply(LLMessageSystem *msg, - void** user_data) -{ - // copy the token out into the stack and delete allocated memory - LLUUID template_token = *((LLUUID*)user_data); - delete user_data; - - LLUUID received_token; - msg->getUUID("TokenBlock", "Token", received_token); - - if(received_token != template_token) - { - llwarns << "Incorrect token in template checksum reply: " - << received_token << llendl; - //return do_normal_idle; - return; - } - - U32 remote_template_checksum = 0; - U8 major_version = 0; - U8 minor_version = 0; - U8 patch_version = 0; - U8 server_version = 0; - U32 flags = 0x0; - msg->getU32("DataBlock", "Checksum", remote_template_checksum); - msg->getU8 ("DataBlock", "MajorVersion", major_version); - msg->getU8 ("DataBlock", "MinorVersion", minor_version); - msg->getU8 ("DataBlock", "PatchVersion", patch_version); - msg->getU8 ("DataBlock", "ServerVersion", server_version); - msg->getU32("DataBlock", "Flags", flags); - - msg->mTemplateConfirmed = TRUE; - if (remote_template_checksum != gMessageSystem->mMessageFileChecksum) - { - llinfos << "Message template out of sync" << llendl; - msg->mTemplateMatches = FALSE; - } - else - { - msg->mTemplateMatches = TRUE; - } -} //static U64 LLMessageSystem::getMessageTimeUsecs(const BOOL update) @@ -4332,14 +3396,32 @@ typedef std::map<const char*, LLMessageBuilder*> BuilderMap; void LLMessageSystem::newMessageFast(const char *name) { - if(LLMessageConfig::isMessageBuiltTemplate(name)) + LLMessageConfig::Flavor message_flavor = + LLMessageConfig::getMessageFlavor(name); + LLMessageConfig::Flavor server_flavor = + LLMessageConfig::getServerDefaultFlavor(); + + if(message_flavor == LLMessageConfig::TEMPLATE_FLAVOR) { mMessageBuilder = mTemplateMessageBuilder; } - else + else if (message_flavor == LLMessageConfig::LLSD_FLAVOR) { mMessageBuilder = mLLSDMessageBuilder; } + // NO_FLAVOR + else + { + if (server_flavor == LLMessageConfig::LLSD_FLAVOR) + { + mMessageBuilder = mLLSDMessageBuilder; + } + // TEMPLATE_FLAVOR or NO_FLAVOR + else + { + mMessageBuilder = mTemplateMessageBuilder; + } + } mSendReliable = FALSE; mMessageBuilder->newMessage(name); } @@ -4802,6 +3884,10 @@ void LLMessageSystem::getIPPort(const char *block, const char *var, U16 &u, void LLMessageSystem::getStringFast(const char *block, const char *var, S32 buffer_size, char *s, S32 blocknum) { + if(buffer_size <= 0) + { + llwarns << "buffer_size <= 0" << llendl; + } mMessageReader->getString(block, var, buffer_size, s, blocknum); } diff --git a/indra/llmessage/message.h b/indra/llmessage/message.h index a4a8022631..9c07227a67 100644 --- a/indra/llmessage/message.h +++ b/indra/llmessage/message.h @@ -1,5 +1,5 @@ /** - * @FILE message.h + * @file message.h * @brief LLMessageSystem class header file * * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc. @@ -30,11 +30,13 @@ #include "lltimer.h" #include "llpacketring.h" #include "llhost.h" +#include "llhttpclient.h" #include "llhttpnode.h" #include "llpacketack.h" #include "message_prehash.h" #include "llstl.h" #include "llmsgvariabletype.h" +#include "llmsgvariabletype.h" const U32 MESSAGE_MAX_STRINGS_LENGTH = 64; const U32 MESSAGE_NUMBER_OF_HASH_BUCKETS = 8192; @@ -106,7 +108,16 @@ const U8 LL_RELIABLE_FLAG = 0x40; const U8 LL_RESENT_FLAG = 0x20; const U8 LL_ACK_FLAG = 0x10; -const S32 LL_MINIMUM_VALID_PACKET_SIZE = LL_PACKET_ID_SIZE + 1; // 4 bytes id + 1 byte message name (high) +// 1 byte flags, 4 bytes sequence, 1 byte offset + 1 byte message name (high) +const S32 LL_MINIMUM_VALID_PACKET_SIZE = LL_PACKET_ID_SIZE + 1; +enum EPacketHeaderLayout +{ + PHL_FLAGS = 0, + PHL_PACKET_ID = 1, + PHL_OFFSET = 5, + PHL_NAME = 6 +}; + const S32 LL_DEFAULT_RELIABLE_RETRIES = 3; const F32 LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS = 1.f; @@ -135,8 +146,6 @@ class LLUUID; class LLMessageSystem; class LLPumpIO; -// message data pieces are used to collect the data called for by the message template - // message system exceptional condition handlers. enum EMessageException { @@ -148,6 +157,7 @@ enum EMessageException typedef void (*msg_exception_callback)(LLMessageSystem*,void*,EMessageException); +// message data pieces are used to collect the data called for by the message template class LLMsgData; class LLMsgBlkData; class LLMessageTemplate; @@ -160,6 +170,8 @@ class LLMessageReader; class LLTemplateMessageReader; class LLSDMessageReader; + + class LLUseCircuitCodeResponder { LOG_CLASS(LLMessageSystem); @@ -184,7 +196,6 @@ class LLMessageSystem // Set this flag to TRUE when you want *very* verbose logs. BOOL mVerboseLog; - U32 mMessageFileChecksum; F32 mMessageFileVersionNumber; typedef std::map<const char *, LLMessageTemplate*> message_template_name_map_t; @@ -430,8 +441,11 @@ public: void forwardReliable(const LLHost &host); void forwardReliable(const U32 circuit_code); + LLHTTPClient::ResponderPtr createResponder(const std::string& name); S32 sendMessage(const LLHost &host); S32 sendMessage(const U32 circuit); + S32 sendMessage(const LLHost &host, const char* name, + const LLSD& message); // BOOL decodeData(const U8 *buffer, const LLHost &host); @@ -508,6 +522,15 @@ public: // The actual sending is done by reallySendDenyTrustedCircuit() void sendDenyTrustedCircuit(const LLHost &host); + /** Return false if host is unknown or untrusted */ + bool isTrustedSender(const LLHost& host) const; + + /** Return false true if name is unknown or untrusted */ + bool isTrustedMessage(const std::string& name) const; + + /** Return false true if name is unknown or trusted */ + bool isUntrustedMessage(const std::string& name) const; + private: // A list of the circuits that need to be sent DenyTrustedCircuit messages. typedef std::set<LLHost> host_set_t; @@ -517,7 +540,6 @@ private: // related to sendDenyTrustedCircuit() void reallySendDenyTrustedCircuit(const LLHost &host); - public: // Use this to establish trust to and from a host. This blocks // until trust has been established, and probably should only be @@ -574,15 +596,6 @@ public: void setMaxMessageTime(const F32 seconds); // Max time to process messages before warning and dumping (neg to disable) void setMaxMessageCounts(const S32 num); // Max number of messages before dumping (neg to disable) - // statics - static BOOL isTemplateConfirmed(); - static BOOL doesTemplateMatch(); - static void sendMessageTemplateChecksum(const LLHost&); - static void processMessageTemplateChecksumReply(LLMessageSystem *msg, - void** user_data); - static void sendSecureMessageTemplateChecksum(const LLHost&); - static void processSecureTemplateChecksumReply(LLMessageSystem *msg, - void** user_data); static U64 getMessageTimeUsecs(const BOOL update = FALSE); // Get the current message system time in microseconds static F64 getMessageTimeSeconds(const BOOL update = FALSE); // Get the current message system time in seconds @@ -593,6 +606,7 @@ public: //static void processAssignCircuitCode(LLMessageSystem* msg, void**); static void processAddCircuitCode(LLMessageSystem* msg, void**); static void processUseCircuitCode(LLMessageSystem* msg, void**); + static void processError(LLMessageSystem* msg, void**); // dispatch llsd message to http node tree static void dispatch(const std::string& msg_name, @@ -603,13 +617,33 @@ public: void setMessageBans(const LLSD& trusted, const LLSD& untrusted); + /** + * @brief send an error message to the host. This is a helper method. + * + * @param host Destination host. + * @param agent_id Destination agent id (may be null) + * @param code An HTTP status compatible error code. + * @param token A specific short string based message + * @param id The transactionid/uniqueid/sessionid whatever. + * @param system The hierarchical path to the system (255 bytes) + * @param message Human readable message (1200 bytes) + * @param data Extra info. + * @return Returns value returned from sendReliable(). + */ + S32 sendError( + const LLHost& host, + const LLUUID& agent_id, + S32 code, + const std::string& token, + const LLUUID& id, + const std::string& system, + const std::string& message, + const LLSD& data); + // Check UDP messages and pump http_pump to receive HTTP messages. bool checkAllMessages(S64 frame_count, LLPumpIO* http_pump); private: - // data used in those internal handlers - BOOL mTemplateConfirmed; - BOOL mTemplateMatches; // The mCircuitCodes is a map from circuit codes to session // ids. This allows us to verify sessions on connect. @@ -619,7 +653,7 @@ private: // Viewers need to track a process session in order to make sure // that no one gives them a bad circuit code. LLUUID mSessionID; - + void addTemplate(LLMessageTemplate *templatep); void clearReceiveState(); BOOL decodeTemplate( const U8* buffer, S32 buffer_size, LLMessageTemplate** msg_template ); @@ -690,6 +724,10 @@ private: bool callHandler(const char *name, bool trustedSource, LLMessageSystem* msg); + + + /** Find, create or revive circuit for host as needed */ + LLCircuitData* findCircuit(const LLHost& host, bool resetPacketId); }; diff --git a/indra/llmessage/message_prehash.cpp b/indra/llmessage/message_prehash.cpp index e153114d1d..67ee5d5675 100644 --- a/indra/llmessage/message_prehash.cpp +++ b/indra/llmessage/message_prehash.cpp @@ -7,14 +7,14 @@ */ /** - * Generated from message template version number 1.053 + * Generated from message template version number 2.000 */ #include "linden_common.h" #include "message.h" -F32 gPrehashVersionNumber = 1.053f; +F32 gPrehashVersionNumber = 2.000f; char * _PREHASH_X; char * _PREHASH_Y; @@ -39,7 +39,6 @@ char * _PREHASH_ScriptAnswerYes; char * _PREHASH_PartnerID; char * _PREHASH_DirLandQuery; char * _PREHASH_TeleportStart; -char * _PREHASH_LogMessages; char * _PREHASH_AboutText; char * _PREHASH_VisualParam; char * _PREHASH_GroupPrims; @@ -47,10 +46,8 @@ char * _PREHASH_SelectedPrims; char * _PREHASH_ID; char * _PREHASH_UUIDNameRequest; char * _PREHASH_UUIDGroupNameRequest; -char * _PREHASH_MoneyTransactionsRequest; char * _PREHASH_GroupAccountTransactionsRequest; char * _PREHASH_MapNameRequest; -char * _PREHASH_MailTaskSimRequest; char * _PREHASH_UpdateSimulator; char * _PREHASH_BillableFactor; char * _PREHASH_ObjectBonusFactor; @@ -60,7 +57,6 @@ char * _PREHASH_ConfirmEnableSimulator; char * _PREHASH_LayerType; char * _PREHASH_OwnerRole; char * _PREHASH_ParcelOverlay; -char * _PREHASH_AdjustBalance; char * _PREHASH_GroupOwned; char * _PREHASH_IP; char * _PREHASH_ChatFromViewer; @@ -95,8 +91,8 @@ char * _PREHASH_SensedData; char * _PREHASH_UpdateBlock; char * _PREHASH_ClassifiedGodDelete; char * _PREHASH_ObjectGrabUpdate; -char * _PREHASH_TaxDate; char * _PREHASH_LocationPos; +char * _PREHASH_TaxDate; char * _PREHASH_StartDateTime; char * _PREHASH_ObjectUpdateCached; char * _PREHASH_Packets; @@ -128,14 +124,11 @@ char * _PREHASH_AABBMin; char * _PREHASH_ClassifiedFlags; char * _PREHASH_ControlFlags; char * _PREHASH_TeleportRequest; -char * _PREHASH_SpaceLocationTeleportRequest; -char * _PREHASH_LeaderBoardRequest; char * _PREHASH_ScriptTeleportRequest; +char * _PREHASH_EstateCovenantRequest; char * _PREHASH_DateUTC; char * _PREHASH_TaskIDs; -char * _PREHASH_EstateCovenantRequest; char * _PREHASH_RequestResult; -char * _PREHASH_ReputationAgentAssign; char * _PREHASH_CanAcceptAgents; char * _PREHASH_ObjectSaleInfo; char * _PREHASH_KillChildAgents; @@ -147,7 +140,6 @@ char * _PREHASH_InfoBlock; char * _PREHASH_OwnershipCost; char * _PREHASH_AvatarNotesUpdate; char * _PREHASH_PID; -char * _PREHASH_TimeString; char * _PREHASH_DirPopularReply; char * _PREHASH_TerrainHeightRange00; char * _PREHASH_SimData; @@ -173,7 +165,6 @@ char * _PREHASH_Objects; char * _PREHASH_URL; char * _PREHASH_CreationDate; char * _PREHASH_JointPivot; -char * _PREHASH_RateeID; char * _PREHASH_FPS; char * _PREHASH_HasTelehub; char * _PREHASH_PathEnd; @@ -198,7 +189,6 @@ char * _PREHASH_GroupNoticesListReply; char * _PREHASH_ParcelAccessListReply; char * _PREHASH_RpcChannelReply; char * _PREHASH_RegionPresenceResponse; -char * _PREHASH_AgentPresenceResponse; char * _PREHASH_CharterMember; char * _PREHASH_EdgeData; char * _PREHASH_NameData; @@ -212,14 +202,12 @@ char * _PREHASH_Mag; char * _PREHASH_ParcelPropertiesRequestByID; char * _PREHASH_ObjectLink; char * _PREHASH_RpcScriptReplyInbound; -char * _PREHASH_BoardData; char * _PREHASH_RezData; char * _PREHASH_RemoveInventoryObjects; char * _PREHASH_GroupProposalBallot; char * _PREHASH_RPCServerIP; char * _PREHASH_Far; char * _PREHASH_GodSessionID; -char * _PREHASH_ViewerDigest; char * _PREHASH_FLAboutText; char * _PREHASH_RegionHandshakeReply; char * _PREHASH_GroupActiveProposalItemReply; @@ -231,7 +219,6 @@ char * _PREHASH_Set; char * _PREHASH_NewName; char * _PREHASH_Key; char * _PREHASH_AgentID; -char * _PREHASH_OnlineStatusRequest; char * _PREHASH_EventNotificationRemoveRequest; char * _PREHASH_NewFolderID; char * _PREHASH_Arc; @@ -243,7 +230,6 @@ char * _PREHASH_Top; char * _PREHASH_MiscStats; char * _PREHASH_ImageID; char * _PREHASH_DataPacket; -char * _PREHASH_ObjectDehinge; char * _PREHASH_You; char * _PREHASH_ScriptControlChange; char * _PREHASH_LoadURL; @@ -260,9 +246,9 @@ char * _PREHASH_Contribution; char * _PREHASH_SetGroupContribution; char * _PREHASH_Offline; char * _PREHASH_AgentIsNowWearing; -char * _PREHASH_SecPerDay; char * _PREHASH_Members; char * _PREHASH_FailedResends; +char * _PREHASH_SecPerDay; char * _PREHASH_CameraCenter; char * _PREHASH_CameraLeftAxis; char * _PREHASH_ExBlock; @@ -270,7 +256,6 @@ char * _PREHASH_Channel; char * _PREHASH_NetTest; char * _PREHASH_DiscardLevel; char * _PREHASH_LayerID; -char * _PREHASH_RatorID; char * _PREHASH_GrabOffset; char * _PREHASH_SimPort; char * _PREHASH_PricePerMeter; @@ -290,21 +275,16 @@ char * _PREHASH_SitName; char * _PREHASH_RegionsVisited; char * _PREHASH_DirClassifiedReply; char * _PREHASH_AvatarClassifiedReply; -char * _PREHASH_ReputationIndividualReply; char * _PREHASH_MediaURL; char * _PREHASH_CompleteAgentMovement; -char * _PREHASH_SpaceIP; char * _PREHASH_ClassifiedID; char * _PREHASH_LocalID; +char * _PREHASH_SpaceIP; char * _PREHASH_RemoveItem; char * _PREHASH_LogFailedMoneyTransaction; char * _PREHASH_ViewerStartAuction; char * _PREHASH_StartAuction; -char * _PREHASH_NameValueName; -char * _PREHASH_AngVelX; char * _PREHASH_DuplicateFlags; -char * _PREHASH_AngVelY; -char * _PREHASH_AngVelZ; char * _PREHASH_TextColor; char * _PREHASH_SlaveID; char * _PREHASH_Charter; @@ -315,21 +295,16 @@ char * _PREHASH_ParcelAuctions; char * _PREHASH_OwnerIsGroup; char * _PREHASH_NameValuePair; char * _PREHASH_RemoveNameValuePair; -char * _PREHASH_GetNameValuePair; char * _PREHASH_BulkUpdateInventory; char * _PREHASH_UpdateTaskInventory; char * _PREHASH_RemoveTaskInventory; char * _PREHASH_MoveTaskInventory; char * _PREHASH_RequestTaskInventory; char * _PREHASH_ReplyTaskInventory; -char * _PREHASH_DeclineInventory; char * _PREHASH_AggregatePermInventory; -char * _PREHASH_SimulatorInfo; -char * _PREHASH_MoneyTransactionsReply; char * _PREHASH_GroupAccountTransactionsReply; -char * _PREHASH_MailTaskSimReply; +char * _PREHASH_SimulatorInfo; char * _PREHASH_WearableData; -char * _PREHASH_StatisticsData; char * _PREHASH_Enabled; char * _PREHASH_Savings; char * _PREHASH_SimulatorLoad; @@ -341,15 +316,12 @@ char * _PREHASH_JoinGroupRequest; char * _PREHASH_LeaveGroupRequest; char * _PREHASH_InviteGroupRequest; char * _PREHASH_LiveHelpGroupRequest; -char * _PREHASH_ServerVersion; char * _PREHASH_PriceParcelClaimFactor; char * _PREHASH_BillableArea; char * _PREHASH_ObjectID; char * _PREHASH_ObjectFlagUpdate; char * _PREHASH_GroupRoleUpdate; char * _PREHASH_RequestInventoryAsset; -char * _PREHASH_RedoLand; -char * _PREHASH_TravelAccess; char * _PREHASH_ChangedGrid; char * _PREHASH_AgentDropGroup; char * _PREHASH_Details; @@ -382,7 +354,6 @@ char * _PREHASH_Timestamp; char * _PREHASH_GlobalPos; char * _PREHASH_GrabOffsetInitial; char * _PREHASH_IsTrial; -char * _PREHASH_FinalizeLogout; char * _PREHASH_ObjectDuplicateOnRay; char * _PREHASH_GroupMembershipCount; char * _PREHASH_MethodData; @@ -418,32 +389,26 @@ char * _PREHASH_TaskData; char * _PREHASH_SimWideMaxPrims; char * _PREHASH_TotalPrims; char * _PREHASH_ProfileBegin; -char * _PREHASH_MoneyDetailsRequest; char * _PREHASH_Request; char * _PREHASH_GroupAccountDetailsRequest; char * _PREHASH_GroupActiveProposalsRequest; char * _PREHASH_StringValue; -char * _PREHASH_ClosestSimulator; char * _PREHASH_Version; char * _PREHASH_OtherCount; char * _PREHASH_MemberCount; char * _PREHASH_ChatData; char * _PREHASH_IsGroupOwned; char * _PREHASH_EnergyEfficiency; -char * _PREHASH_MaxPlace; char * _PREHASH_PickInfoUpdate; char * _PREHASH_PickDelete; char * _PREHASH_ScriptReset; char * _PREHASH_Requester; char * _PREHASH_ForSale; char * _PREHASH_NearestLandingRegionReply; -char * _PREHASH_RecordAgentPresence; -char * _PREHASH_EraseAgentPresence; char * _PREHASH_ParcelID; char * _PREHASH_Godlike; char * _PREHASH_TotalDebits; char * _PREHASH_Direction; -char * _PREHASH_Appearance; char * _PREHASH_HealthData; char * _PREHASH_LeftAxis; char * _PREHASH_LocationBlock; @@ -451,41 +416,31 @@ char * _PREHASH_ObjectImage; char * _PREHASH_TerrainStartHeight00; char * _PREHASH_TerrainStartHeight01; char * _PREHASH_TerrainStartHeight10; -char * _PREHASH_ObjectHinge; char * _PREHASH_TerrainStartHeight11; -char * _PREHASH_MetersPerGrid; char * _PREHASH_WaterHeight; char * _PREHASH_FetchInventoryReply; -char * _PREHASH_MoneySummaryReply; char * _PREHASH_GroupAccountSummaryReply; char * _PREHASH_AttachedSound; char * _PREHASH_ParamInUse; char * _PREHASH_GodKickUser; char * _PREHASH_PickName; char * _PREHASH_TaskName; -char * _PREHASH_SubType; char * _PREHASH_ObjectCount; char * _PREHASH_RegionPresenceRequestByHandle; char * _PREHASH_RezSingleAttachmentFromInv; char * _PREHASH_ChildAgentUpdate; -char * _PREHASH_ToID; -char * _PREHASH_ViewerPort; char * _PREHASH_IsOwnerGroup; char * _PREHASH_AgentHeightWidth; char * _PREHASH_VerticalAngle; char * _PREHASH_WearableType; char * _PREHASH_AggregatePermNextOwner; char * _PREHASH_ShowInList; -char * _PREHASH_PositionSuggestion; char * _PREHASH_UpdateParcel; -char * _PREHASH_ClearAgentSessions; char * _PREHASH_SetAlwaysRun; char * _PREHASH_NVPair; char * _PREHASH_SearchType; char * _PREHASH_ObjectSpinStart; char * _PREHASH_UseEstateSun; -char * _PREHASH_LogoutBlock; -char * _PREHASH_RelayLogControl; char * _PREHASH_RegionID; char * _PREHASH_AbuseRegionID; char * _PREHASH_Creator; @@ -494,14 +449,12 @@ char * _PREHASH_DirEventsReply; char * _PREHASH_EventInfoReply; char * _PREHASH_UserInfoReply; char * _PREHASH_PathRadiusOffset; -char * _PREHASH_SessionInfo; char * _PREHASH_TextureData; char * _PREHASH_ChatPass; char * _PREHASH_TargetID; char * _PREHASH_DefaultPayPrice; char * _PREHASH_UserLocation; char * _PREHASH_MaxPrims; -char * _PREHASH_RegionIP; char * _PREHASH_LandmarkID; char * _PREHASH_InitiateDownload; char * _PREHASH_Name; @@ -509,18 +462,13 @@ char * _PREHASH_OtherCleanTime; char * _PREHASH_ParcelSetOtherCleanTime; char * _PREHASH_TeleportPriceExponent; char * _PREHASH_Gain; -char * _PREHASH_VelX; char * _PREHASH_PacketAck; char * _PREHASH_PathSkew; -char * _PREHASH_Negative; -char * _PREHASH_VelY; char * _PREHASH_SimulatorShutdownRequest; char * _PREHASH_NearestLandingRegionRequest; -char * _PREHASH_VelZ; char * _PREHASH_OtherID; char * _PREHASH_MemberID; char * _PREHASH_MapLayerRequest; -char * _PREHASH_PatchVersion; char * _PREHASH_ObjectScale; char * _PREHASH_TargetIP; char * _PREHASH_Redo; @@ -563,27 +511,20 @@ char * _PREHASH_Perp; char * _PREHASH_Code; char * _PREHASH_InvType; char * _PREHASH_AgentFOV; -char * _PREHASH_BulkMoneyTransfer; char * _PREHASH_Audible; char * _PREHASH_AuctionData; char * _PREHASH_IDBlock; -char * _PREHASH_ReputationData; char * _PREHASH_West; char * _PREHASH_Undo; char * _PREHASH_TotalNumItems; char * _PREHASH_Info; char * _PREHASH_Area; -char * _PREHASH_Behavior; char * _PREHASH_SimCrashed; char * _PREHASH_Text; -char * _PREHASH_AgentToNewRegion; char * _PREHASH_PriceGroupCreate; char * _PREHASH_ObjectShape; char * _PREHASH_GroupRoleDataReply; -char * _PREHASH_PosX; -char * _PREHASH_PosY; char * _PREHASH_MuteCRC; -char * _PREHASH_PosZ; char * _PREHASH_Size; char * _PREHASH_FromAddress; char * _PREHASH_Body; @@ -601,16 +542,14 @@ char * _PREHASH_Stat; char * _PREHASH_SoundID; char * _PREHASH_Item; char * _PREHASH_User; -char * _PREHASH_RemoteInfos; char * _PREHASH_Prey; -char * _PREHASH_UsecSinceStart; char * _PREHASH_RayStart; +char * _PREHASH_UsecSinceStart; char * _PREHASH_ParcelData; char * _PREHASH_CameraUpAxis; char * _PREHASH_ScriptDialog; char * _PREHASH_MasterParcelData; char * _PREHASH_Invalid; -char * _PREHASH_MinPlace; char * _PREHASH_ProfileCurve; char * _PREHASH_ParcelAccessListUpdate; char * _PREHASH_MuteListUpdate; @@ -629,14 +568,12 @@ char * _PREHASH_DeRezObject; char * _PREHASH_IsTemporary; char * _PREHASH_InsigniaID; char * _PREHASH_CheckFlags; -char * _PREHASH_TransferPriority; char * _PREHASH_EventID; char * _PREHASH_Selected; char * _PREHASH_FromAgentId; char * _PREHASH_Type; char * _PREHASH_ChatType; char * _PREHASH_ReportData; -char * _PREHASH_LeaderBoardData; char * _PREHASH_RequestBlock; char * _PREHASH_GrantData; char * _PREHASH_DetachAttachmentIntoInv; @@ -652,12 +589,9 @@ char * _PREHASH_OnlineNotification; char * _PREHASH_OfflineNotification; char * _PREHASH_SendPostcard; char * _PREHASH_RequestFlags; -char * _PREHASH_MoneyHistoryRequest; -char * _PREHASH_MoneySummaryRequest; char * _PREHASH_GroupAccountSummaryRequest; char * _PREHASH_GroupVoteHistoryRequest; char * _PREHASH_ParamValue; -char * _PREHASH_Checksum; char * _PREHASH_MaxAgents; char * _PREHASH_CreateNewOutfitAttachments; char * _PREHASH_RegionHandle; @@ -667,12 +601,10 @@ char * _PREHASH_AvatarInterestsUpdate; char * _PREHASH_GroupNoticeID; char * _PREHASH_ParcelName; char * _PREHASH_PriceObjectRent; -char * _PREHASH_ConnectAgentToUserserver; -char * _PREHASH_ConnectToUserserver; char * _PREHASH_OfferCallingCard; -char * _PREHASH_AgentAccess; char * _PREHASH_AcceptCallingCard; char * _PREHASH_DeclineCallingCard; +char * _PREHASH_AgentAccess; char * _PREHASH_DataHomeLocationReply; char * _PREHASH_EventLocationReply; char * _PREHASH_TerseDateID; @@ -690,8 +622,8 @@ char * _PREHASH_Invoice; char * _PREHASH_IntervalDays; char * _PREHASH_PathScaleX; char * _PREHASH_FromTaskID; -char * _PREHASH_TimeInfo; char * _PREHASH_PathScaleY; +char * _PREHASH_TimeInfo; char * _PREHASH_PublicCount; char * _PREHASH_ParcelJoin; char * _PREHASH_GroupRolesCount; @@ -716,7 +648,6 @@ char * _PREHASH_NearestLandingRegionUpdated; char * _PREHASH_PassToAgent; char * _PREHASH_PreyAgent; char * _PREHASH_SimStats; -char * _PREHASH_Options; char * _PREHASH_LogoutReply; char * _PREHASH_FeatureDisabled; char * _PREHASH_ObjectLocalID; @@ -727,10 +658,8 @@ char * _PREHASH_Destination; char * _PREHASH_MasterID; char * _PREHASH_TransferData; char * _PREHASH_WantToMask; -char * _PREHASH_AvatarData; char * _PREHASH_ParcelSelectObjects; char * _PREHASH_ExtraParams; -char * _PREHASH_LogLogin; char * _PREHASH_CreatorID; char * _PREHASH_Summary; char * _PREHASH_BuyObjectInventory; @@ -771,8 +700,8 @@ char * _PREHASH_ButtonLabel; char * _PREHASH_GranterID; char * _PREHASH_WantToText; char * _PREHASH_ReportType; -char * _PREHASH_DataBlock; char * _PREHASH_SimulatorReady; +char * _PREHASH_DataBlock; char * _PREHASH_AnimationSourceList; char * _PREHASH_SubscribeLoad; char * _PREHASH_UnsubscribeLoad; @@ -799,9 +728,8 @@ char * _PREHASH_Header; char * _PREHASH_GestureFlags; char * _PREHASH_XferID; char * _PREHASH_StatValue; -char * _PREHASH_PickID; char * _PREHASH_TaskID; -char * _PREHASH_GridsPerEdge; +char * _PREHASH_PickID; char * _PREHASH_RayEnd; char * _PREHASH_Throttles; char * _PREHASH_RebakeAvatarTextures; @@ -814,30 +742,24 @@ char * _PREHASH_Access; char * _PREHASH_TitleRoleID; char * _PREHASH_SquareMetersCredit; char * _PREHASH_Filename; -char * _PREHASH_SecuredTemplateChecksumRequest; -char * _PREHASH_TemplateChecksumRequest; -char * _PREHASH_AgentPresenceRequest; char * _PREHASH_ClassifiedInfoRequest; char * _PREHASH_ParcelInfoRequest; char * _PREHASH_ParcelObjectOwnersRequest; char * _PREHASH_TeleportLandmarkRequest; char * _PREHASH_EventInfoRequest; -char * _PREHASH_ChatFromSimulator; -char * _PREHASH_PickInfoRequest; char * _PREHASH_MoneyBalanceRequest; char * _PREHASH_GroupMembersRequest; char * _PREHASH_GroupRoleMembersRequest; +char * _PREHASH_ChatFromSimulator; char * _PREHASH_OldFolderID; char * _PREHASH_UserInfoRequest; char * _PREHASH_TextureID; char * _PREHASH_ProfileURL; char * _PREHASH_Handle; -char * _PREHASH_StartParcelRenameAck; char * _PREHASH_ButtonIndex; char * _PREHASH_GetScriptRunning; char * _PREHASH_SetScriptRunning; char * _PREHASH_Health; -char * _PREHASH_FileID; char * _PREHASH_CircuitInfo; char * _PREHASH_ObjectBuy; char * _PREHASH_ProfileEnd; @@ -862,7 +784,6 @@ char * _PREHASH_PingID; char * _PREHASH_Change; char * _PREHASH_Height; char * _PREHASH_Region; -char * _PREHASH_MoneyHistoryReply; char * _PREHASH_TelehubInfo; char * _PREHASH_StateSave; char * _PREHASH_RoleData; @@ -873,11 +794,10 @@ char * _PREHASH_ParcelGodMarkAsContent; char * _PREHASH_UsePhysics; char * _PREHASH_RegionDenyTransacted; char * _PREHASH_JointType; -char * _PREHASH_TaxEstimate; char * _PREHASH_ObjectTaxEstimate; char * _PREHASH_LightTaxEstimate; -char * _PREHASH_TeleportLandingStatusChanged; char * _PREHASH_LandTaxEstimate; +char * _PREHASH_TeleportLandingStatusChanged; char * _PREHASH_GroupTaxEstimate; char * _PREHASH_AvgViewerFPS; char * _PREHASH_Buttons; @@ -909,8 +829,6 @@ char * _PREHASH_WinnerID; char * _PREHASH_ChannelType; char * _PREHASH_NonExemptMembers; char * _PREHASH_Agents; -char * _PREHASH_SimulatorStart; -char * _PREHASH_Enable; char * _PREHASH_MemberData; char * _PREHASH_ToGroupID; char * _PREHASH_ImageNotInDatabase; @@ -918,27 +836,21 @@ char * _PREHASH_StartDate; char * _PREHASH_AnimID; char * _PREHASH_Serial; char * _PREHASH_AbuseRegionName; -char * _PREHASH_ControlPort; char * _PREHASH_ModifyLand; char * _PREHASH_Digest; char * _PREHASH_Victim; char * _PREHASH_Script; -char * _PREHASH_TemplateChecksumReply; char * _PREHASH_PickInfoReply; char * _PREHASH_MoneyBalanceReply; char * _PREHASH_RoutedMoneyBalanceReply; char * _PREHASH_RoleID; char * _PREHASH_RegionInfo; -char * _PREHASH_Sequence; char * _PREHASH_GodUpdateRegionInfo; -char * _PREHASH_LocalX; -char * _PREHASH_LocalY; char * _PREHASH_StartAnim; -char * _PREHASH_Location; char * _PREHASH_Action; +char * _PREHASH_Location; char * _PREHASH_Rights; char * _PREHASH_SearchDir; -char * _PREHASH_Active; char * _PREHASH_TransferRequest; char * _PREHASH_ScriptSensorRequest; char * _PREHASH_MoneyTransferRequest; @@ -949,8 +861,6 @@ char * _PREHASH_Center; char * _PREHASH_SharedData; char * _PREHASH_PSBlock; char * _PREHASH_UUIDNameBlock; -char * _PREHASH_Viewer; -char * _PREHASH_GroupNoticeDelete; char * _PREHASH_GroupTitleUpdate; char * _PREHASH_Method; char * _PREHASH_TouchName; @@ -962,11 +872,9 @@ char * _PREHASH_GodlikeMessage; char * _PREHASH_SystemMessage; char * _PREHASH_BodyRotation; char * _PREHASH_SearchRegions; -char * _PREHASH_Ignore; char * _PREHASH_AnimationData; char * _PREHASH_StatID; char * _PREHASH_ItemID; -char * _PREHASH_AvatarStatisticsReply; char * _PREHASH_ScriptDialogReply; char * _PREHASH_RegionIDAndHandleReply; char * _PREHASH_CameraAtOffset; @@ -991,7 +899,6 @@ char * _PREHASH_OldItemID; char * _PREHASH_RegionPort; char * _PREHASH_PriceEnergyUnit; char * _PREHASH_Bitmap; -char * _PREHASH_TrackAgentSession; char * _PREHASH_CacheMissType; char * _PREHASH_VFileID; char * _PREHASH_GroupInsigniaID; @@ -1039,7 +946,6 @@ char * _PREHASH_MeanCollisionAlert; char * _PREHASH_CanAcceptTasks; char * _PREHASH_ItemData; char * _PREHASH_AnimationList; -char * _PREHASH_PassObject; char * _PREHASH_Reputation; char * _PREHASH_IntValue; char * _PREHASH_TargetType; @@ -1062,10 +968,8 @@ char * _PREHASH_ParcelBuy; char * _PREHASH_DirFindQueryBackend; char * _PREHASH_DirPlacesQueryBackend; char * _PREHASH_DirClassifiedQueryBackend; -char * _PREHASH_DirPicksQueryBackend; char * _PREHASH_DirLandQueryBackend; char * _PREHASH_DirPopularQueryBackend; -char * _PREHASH_LogoutDemand; char * _PREHASH_HistoryData; char * _PREHASH_SnapshotID; char * _PREHASH_Aspect; @@ -1073,7 +977,6 @@ char * _PREHASH_ParamSize; char * _PREHASH_VoteCast; char * _PREHASH_CastsShadows; char * _PREHASH_EveryoneMask; -char * _PREHASH_SetSunPhase; char * _PREHASH_ObjectSpinUpdate; char * _PREHASH_MaturePublish; char * _PREHASH_UseExistingAsset; @@ -1082,7 +985,6 @@ char * _PREHASH_ParcelLocalID; char * _PREHASH_TeleportCancel; char * _PREHASH_UnixTime; char * _PREHASH_QueryFlags; -char * _PREHASH_LastExecFroze; char * _PREHASH_AlwaysRun; char * _PREHASH_Bottom; char * _PREHASH_ButtonData; @@ -1101,7 +1003,6 @@ char * _PREHASH_NVPairs; char * _PREHASH_GroupNoticesListRequest; char * _PREHASH_ParcelAccessListRequest; char * _PREHASH_MuteListRequest; -char * _PREHASH_StartPeriod; char * _PREHASH_RpcChannelRequest; char * _PREHASH_LandStatRequest; char * _PREHASH_PlacesQuery; @@ -1129,34 +1030,27 @@ char * _PREHASH_SnapSelection; char * _PREHASH_SoundTrigger; char * _PREHASH_TerrainRaiseLimit; char * _PREHASH_Quorum; -char * _PREHASH_TokenBlock; char * _PREHASH_AgentBlock; char * _PREHASH_CommandBlock; char * _PREHASH_PricePublicObjectDecay; char * _PREHASH_SpawnPointPos; -char * _PREHASH_AttachedSoundCutoffRadius; char * _PREHASH_VolumeDetail; char * _PREHASH_FromAgentName; char * _PREHASH_Range; char * _PREHASH_DirectoryVisibility; char * _PREHASH_PublicIP; char * _PREHASH_TeleportFailed; -char * _PREHASH_OnlineStatusReply; -char * _PREHASH_RequestAvatarInfo; char * _PREHASH_PreloadSound; char * _PREHASH_ScreenshotID; char * _PREHASH_CovenantTimestamp; char * _PREHASH_OldestUnacked; char * _PREHASH_SimulatorIP; -char * _PREHASH_ObjectImport; char * _PREHASH_Value; char * _PREHASH_JointAxisOrAnchor; char * _PREHASH_Test0; char * _PREHASH_Test1; char * _PREHASH_Test2; char * _PREHASH_SunPhase; -char * _PREHASH_Place; -char * _PREHASH_Phase; char * _PREHASH_ParcelDivide; char * _PREHASH_PriceObjectClaim; char * _PREHASH_Field; @@ -1166,7 +1060,6 @@ char * _PREHASH_LiveHelpGroupReply; char * _PREHASH_Score; char * _PREHASH_Image; char * _PREHASH_ObjectClickAction; -char * _PREHASH_Delta; char * _PREHASH_Parameter; char * _PREHASH_Flags; char * _PREHASH_Plane; @@ -1176,26 +1069,24 @@ char * _PREHASH_DirFindQuery; char * _PREHASH_Textures; char * _PREHASH_EventData; char * _PREHASH_Final; +char * _PREHASH_System; char * _PREHASH_TelehubPos; char * _PREHASH_ReportAutosaveCrash; char * _PREHASH_CreateTrustedCircuit; char * _PREHASH_DenyTrustedCircuit; char * _PREHASH_RequestTrustedCircuit; char * _PREHASH_Codec; -char * _PREHASH_Level; char * _PREHASH_Modal; char * _PREHASH_ChildAgentUnknown; char * _PREHASH_LandingType; char * _PREHASH_ScriptRunningReply; -char * _PREHASH_MoneyDetailsReply; char * _PREHASH_Reply; +char * _PREHASH_GroupAccountDetailsReply; char * _PREHASH_TelehubRot; -char * _PREHASH_RequestFriendship; char * _PREHASH_AcceptFriendship; -char * _PREHASH_GroupAccountDetailsReply; +char * _PREHASH_ItemType; char * _PREHASH_DwellInfo; char * _PREHASH_AgentResume; -char * _PREHASH_ItemType; char * _PREHASH_MailFilter; char * _PREHASH_Disconnect; char * _PREHASH_SimPosition; @@ -1222,7 +1113,6 @@ char * _PREHASH_VoteType; char * _PREHASH_CategoryID; char * _PREHASH_Token; char * _PREHASH_AggregatePerms; -char * _PREHASH_StartParcelRemoveAck; char * _PREHASH_ObjectSelect; char * _PREHASH_ForceObjectSelect; char * _PREHASH_Price; @@ -1251,7 +1141,6 @@ char * _PREHASH_Notes; char * _PREHASH_AvatarID; char * _PREHASH_FounderID; char * _PREHASH_EndPointID; -char * _PREHASH_StipendEstimate; char * _PREHASH_LocationLookAt; char * _PREHASH_Sound; char * _PREHASH_Cover; @@ -1271,12 +1160,12 @@ char * _PREHASH_ProfileHollow; char * _PREHASH_GroupRoleChanges; char * _PREHASH_Count; char * _PREHASH_South; -char * _PREHASH_Entry; char * _PREHASH_ObjectUpdateCompressed; char * _PREHASH_MuteFlags; char * _PREHASH_Group; char * _PREHASH_AgentPause; char * _PREHASH_LanguagesText; +char * _PREHASH_Error; char * _PREHASH_InternalScriptMail; char * _PREHASH_FindAgent; char * _PREHASH_AgentData; @@ -1285,7 +1174,6 @@ char * _PREHASH_AssetBlock; char * _PREHASH_AcceptNotices; char * _PREHASH_SetGroupAcceptNotices; char * _PREHASH_CloseCircuit; -char * _PREHASH_LogControl; char * _PREHASH_TeleportFinish; char * _PREHASH_PathRevolutions; char * _PREHASH_ClassifiedInfoReply; @@ -1302,7 +1190,6 @@ char * _PREHASH_DataHomeLocationRequest; char * _PREHASH_EventNotificationAddRequest; char * _PREHASH_ParcelDwellRequest; char * _PREHASH_EventLocationRequest; -char * _PREHASH_EndPeriod; char * _PREHASH_SetStartLocationRequest; char * _PREHASH_QueryStart; char * _PREHASH_EjectData; @@ -1315,7 +1202,6 @@ char * _PREHASH_ParcelRelease; char * _PREHASH_VFileType; char * _PREHASH_EjectGroupMemberReply; char * _PREHASH_ImageData; -char * _PREHASH_SpaceServerSimulatorTimeMessage; char * _PREHASH_SimulatorViewerTimeMessage; char * _PREHASH_Rotation; char * _PREHASH_Selection; @@ -1323,7 +1209,6 @@ char * _PREHASH_TransactionData; char * _PREHASH_OperationData; char * _PREHASH_ExpirationDate; char * _PREHASH_ParcelDeedToGroup; -char * _PREHASH_DirPicksReply; char * _PREHASH_AvatarPicksReply; char * _PREHASH_GroupTitlesReply; char * _PREHASH_AgentInfo; @@ -1334,8 +1219,8 @@ char * _PREHASH_PassPrice; char * _PREHASH_SourceID; char * _PREHASH_ChangeUserRights; char * _PREHASH_TeleportFlags; -char * _PREHASH_AssetData; char * _PREHASH_SlaveParcelData; +char * _PREHASH_AssetData; char * _PREHASH_MultipleObjectUpdate; char * _PREHASH_ObjectUpdate; char * _PREHASH_ImprovedTerseObjectUpdate; @@ -1351,7 +1236,6 @@ char * _PREHASH_TaskLocalID; char * _PREHASH_ClaimDate; char * _PREHASH_MergeParcel; char * _PREHASH_Priority; -char * _PREHASH_Building; char * _PREHASH_QueryText; char * _PREHASH_GroupNoticeAdd; char * _PREHASH_ReturnType; @@ -1361,7 +1245,6 @@ char * _PREHASH_HeaderData; char * _PREHASH_RequestMultipleObjects; char * _PREHASH_RetrieveInstantMessages; char * _PREHASH_OpenCircuit; -char * _PREHASH_SecureSessionID; char * _PREHASH_CrossedRegion; char * _PREHASH_DirGroupsReply; char * _PREHASH_AvatarGroupsReply; @@ -1372,18 +1255,14 @@ char * _PREHASH_Position; char * _PREHASH_ParentEstate; char * _PREHASH_EstateName; char * _PREHASH_MuteName; -char * _PREHASH_StartParcelRename; -char * _PREHASH_BulkParcelRename; char * _PREHASH_ParcelRename; char * _PREHASH_ViewerFilename; -char * _PREHASH_Positive; char * _PREHASH_UserReportInternal; char * _PREHASH_AvatarPropertiesRequest; char * _PREHASH_ParcelPropertiesRequest; char * _PREHASH_GroupProfileRequest; char * _PREHASH_AgentDataUpdateRequest; char * _PREHASH_PriceObjectScaleFactor; -char * _PREHASH_DirPicksQuery; char * _PREHASH_OpenEnrollment; char * _PREHASH_GroupData; char * _PREHASH_RequestGodlikePowers; @@ -1394,7 +1273,6 @@ char * _PREHASH_Controls; char * _PREHASH_FirstDetachAll; char * _PREHASH_EstateID; char * _PREHASH_ImprovedInstantMessage; -char * _PREHASH_AgentQuit; char * _PREHASH_CheckParcelSales; char * _PREHASH_ParcelSales; char * _PREHASH_CurrentInterval; @@ -1411,12 +1289,8 @@ char * _PREHASH_OwnerIDs; char * _PREHASH_SystemKickUser; char * _PREHASH_TransactionTime; char * _PREHASH_TimeToLive; -char * _PREHASH_StartParcelRemove; -char * _PREHASH_BulkParcelRemove; char * _PREHASH_OldAgentID; -char * _PREHASH_BonusEstimate; char * _PREHASH_MusicURL; -char * _PREHASH_CompleteLure; char * _PREHASH_ParcelPrimBonus; char * _PREHASH_EjectUser; char * _PREHASH_CoarseLocationUpdate; @@ -1449,10 +1323,6 @@ char * _PREHASH_ParcelProperties; char * _PREHASH_EstateOwnerID; char * _PREHASH_LogoutRequest; char * _PREHASH_AssetUploadRequest; -char * _PREHASH_ReputationIndividualRequest; -char * _PREHASH_MajorVersion; -char * _PREHASH_MinorVersion; -char * _PREHASH_SimulatorAssign; char * _PREHASH_TransactionType; char * _PREHASH_AvatarPropertiesUpdate; char * _PREHASH_ParcelPropertiesUpdate; @@ -1461,7 +1331,6 @@ char * _PREHASH_AbortXfer; char * _PREHASH_DeRezAck; char * _PREHASH_TakeControls; char * _PREHASH_DirLandReply; -char * _PREHASH_SpaceLocationTeleportReply; char * _PREHASH_MuteType; char * _PREHASH_IMViaEMail; char * _PREHASH_RentPrice; @@ -1502,7 +1371,6 @@ void init_prehash_data() _PREHASH_PartnerID = gMessageStringTable.getString("PartnerID"); _PREHASH_DirLandQuery = gMessageStringTable.getString("DirLandQuery"); _PREHASH_TeleportStart = gMessageStringTable.getString("TeleportStart"); - _PREHASH_LogMessages = gMessageStringTable.getString("LogMessages"); _PREHASH_AboutText = gMessageStringTable.getString("AboutText"); _PREHASH_VisualParam = gMessageStringTable.getString("VisualParam"); _PREHASH_GroupPrims = gMessageStringTable.getString("GroupPrims"); @@ -1510,10 +1378,8 @@ void init_prehash_data() _PREHASH_ID = gMessageStringTable.getString("ID"); _PREHASH_UUIDNameRequest = gMessageStringTable.getString("UUIDNameRequest"); _PREHASH_UUIDGroupNameRequest = gMessageStringTable.getString("UUIDGroupNameRequest"); - _PREHASH_MoneyTransactionsRequest = gMessageStringTable.getString("MoneyTransactionsRequest"); _PREHASH_GroupAccountTransactionsRequest = gMessageStringTable.getString("GroupAccountTransactionsRequest"); _PREHASH_MapNameRequest = gMessageStringTable.getString("MapNameRequest"); - _PREHASH_MailTaskSimRequest = gMessageStringTable.getString("MailTaskSimRequest"); _PREHASH_UpdateSimulator = gMessageStringTable.getString("UpdateSimulator"); _PREHASH_BillableFactor = gMessageStringTable.getString("BillableFactor"); _PREHASH_ObjectBonusFactor = gMessageStringTable.getString("ObjectBonusFactor"); @@ -1523,7 +1389,6 @@ void init_prehash_data() _PREHASH_LayerType = gMessageStringTable.getString("LayerType"); _PREHASH_OwnerRole = gMessageStringTable.getString("OwnerRole"); _PREHASH_ParcelOverlay = gMessageStringTable.getString("ParcelOverlay"); - _PREHASH_AdjustBalance = gMessageStringTable.getString("AdjustBalance"); _PREHASH_GroupOwned = gMessageStringTable.getString("GroupOwned"); _PREHASH_IP = gMessageStringTable.getString("IP"); _PREHASH_ChatFromViewer = gMessageStringTable.getString("ChatFromViewer"); @@ -1558,8 +1423,8 @@ void init_prehash_data() _PREHASH_UpdateBlock = gMessageStringTable.getString("UpdateBlock"); _PREHASH_ClassifiedGodDelete = gMessageStringTable.getString("ClassifiedGodDelete"); _PREHASH_ObjectGrabUpdate = gMessageStringTable.getString("ObjectGrabUpdate"); - _PREHASH_TaxDate = gMessageStringTable.getString("TaxDate"); _PREHASH_LocationPos = gMessageStringTable.getString("LocationPos"); + _PREHASH_TaxDate = gMessageStringTable.getString("TaxDate"); _PREHASH_StartDateTime = gMessageStringTable.getString("StartDateTime"); _PREHASH_ObjectUpdateCached = gMessageStringTable.getString("ObjectUpdateCached"); _PREHASH_Packets = gMessageStringTable.getString("Packets"); @@ -1591,14 +1456,11 @@ void init_prehash_data() _PREHASH_ClassifiedFlags = gMessageStringTable.getString("ClassifiedFlags"); _PREHASH_ControlFlags = gMessageStringTable.getString("ControlFlags"); _PREHASH_TeleportRequest = gMessageStringTable.getString("TeleportRequest"); - _PREHASH_SpaceLocationTeleportRequest = gMessageStringTable.getString("SpaceLocationTeleportRequest"); - _PREHASH_LeaderBoardRequest = gMessageStringTable.getString("LeaderBoardRequest"); _PREHASH_ScriptTeleportRequest = gMessageStringTable.getString("ScriptTeleportRequest"); + _PREHASH_EstateCovenantRequest = gMessageStringTable.getString("EstateCovenantRequest"); _PREHASH_DateUTC = gMessageStringTable.getString("DateUTC"); _PREHASH_TaskIDs = gMessageStringTable.getString("TaskIDs"); - _PREHASH_EstateCovenantRequest = gMessageStringTable.getString("EstateCovenantRequest"); _PREHASH_RequestResult = gMessageStringTable.getString("RequestResult"); - _PREHASH_ReputationAgentAssign = gMessageStringTable.getString("ReputationAgentAssign"); _PREHASH_CanAcceptAgents = gMessageStringTable.getString("CanAcceptAgents"); _PREHASH_ObjectSaleInfo = gMessageStringTable.getString("ObjectSaleInfo"); _PREHASH_KillChildAgents = gMessageStringTable.getString("KillChildAgents"); @@ -1610,7 +1472,6 @@ void init_prehash_data() _PREHASH_OwnershipCost = gMessageStringTable.getString("OwnershipCost"); _PREHASH_AvatarNotesUpdate = gMessageStringTable.getString("AvatarNotesUpdate"); _PREHASH_PID = gMessageStringTable.getString("PID"); - _PREHASH_TimeString = gMessageStringTable.getString("TimeString"); _PREHASH_DirPopularReply = gMessageStringTable.getString("DirPopularReply"); _PREHASH_TerrainHeightRange00 = gMessageStringTable.getString("TerrainHeightRange00"); _PREHASH_SimData = gMessageStringTable.getString("SimData"); @@ -1636,7 +1497,6 @@ void init_prehash_data() _PREHASH_URL = gMessageStringTable.getString("URL"); _PREHASH_CreationDate = gMessageStringTable.getString("CreationDate"); _PREHASH_JointPivot = gMessageStringTable.getString("JointPivot"); - _PREHASH_RateeID = gMessageStringTable.getString("RateeID"); _PREHASH_FPS = gMessageStringTable.getString("FPS"); _PREHASH_HasTelehub = gMessageStringTable.getString("HasTelehub"); _PREHASH_PathEnd = gMessageStringTable.getString("PathEnd"); @@ -1661,7 +1521,6 @@ void init_prehash_data() _PREHASH_ParcelAccessListReply = gMessageStringTable.getString("ParcelAccessListReply"); _PREHASH_RpcChannelReply = gMessageStringTable.getString("RpcChannelReply"); _PREHASH_RegionPresenceResponse = gMessageStringTable.getString("RegionPresenceResponse"); - _PREHASH_AgentPresenceResponse = gMessageStringTable.getString("AgentPresenceResponse"); _PREHASH_CharterMember = gMessageStringTable.getString("CharterMember"); _PREHASH_EdgeData = gMessageStringTable.getString("EdgeData"); _PREHASH_NameData = gMessageStringTable.getString("NameData"); @@ -1675,14 +1534,12 @@ void init_prehash_data() _PREHASH_ParcelPropertiesRequestByID = gMessageStringTable.getString("ParcelPropertiesRequestByID"); _PREHASH_ObjectLink = gMessageStringTable.getString("ObjectLink"); _PREHASH_RpcScriptReplyInbound = gMessageStringTable.getString("RpcScriptReplyInbound"); - _PREHASH_BoardData = gMessageStringTable.getString("BoardData"); _PREHASH_RezData = gMessageStringTable.getString("RezData"); _PREHASH_RemoveInventoryObjects = gMessageStringTable.getString("RemoveInventoryObjects"); _PREHASH_GroupProposalBallot = gMessageStringTable.getString("GroupProposalBallot"); _PREHASH_RPCServerIP = gMessageStringTable.getString("RPCServerIP"); _PREHASH_Far = gMessageStringTable.getString("Far"); _PREHASH_GodSessionID = gMessageStringTable.getString("GodSessionID"); - _PREHASH_ViewerDigest = gMessageStringTable.getString("ViewerDigest"); _PREHASH_FLAboutText = gMessageStringTable.getString("FLAboutText"); _PREHASH_RegionHandshakeReply = gMessageStringTable.getString("RegionHandshakeReply"); _PREHASH_GroupActiveProposalItemReply = gMessageStringTable.getString("GroupActiveProposalItemReply"); @@ -1694,7 +1551,6 @@ void init_prehash_data() _PREHASH_NewName = gMessageStringTable.getString("NewName"); _PREHASH_Key = gMessageStringTable.getString("Key"); _PREHASH_AgentID = gMessageStringTable.getString("AgentID"); - _PREHASH_OnlineStatusRequest = gMessageStringTable.getString("OnlineStatusRequest"); _PREHASH_EventNotificationRemoveRequest = gMessageStringTable.getString("EventNotificationRemoveRequest"); _PREHASH_NewFolderID = gMessageStringTable.getString("NewFolderID"); _PREHASH_Arc = gMessageStringTable.getString("Arc"); @@ -1706,7 +1562,6 @@ void init_prehash_data() _PREHASH_MiscStats = gMessageStringTable.getString("MiscStats"); _PREHASH_ImageID = gMessageStringTable.getString("ImageID"); _PREHASH_DataPacket = gMessageStringTable.getString("DataPacket"); - _PREHASH_ObjectDehinge = gMessageStringTable.getString("ObjectDehinge"); _PREHASH_You = gMessageStringTable.getString("You"); _PREHASH_ScriptControlChange = gMessageStringTable.getString("ScriptControlChange"); _PREHASH_LoadURL = gMessageStringTable.getString("LoadURL"); @@ -1723,9 +1578,9 @@ void init_prehash_data() _PREHASH_SetGroupContribution = gMessageStringTable.getString("SetGroupContribution"); _PREHASH_Offline = gMessageStringTable.getString("Offline"); _PREHASH_AgentIsNowWearing = gMessageStringTable.getString("AgentIsNowWearing"); - _PREHASH_SecPerDay = gMessageStringTable.getString("SecPerDay"); _PREHASH_Members = gMessageStringTable.getString("Members"); _PREHASH_FailedResends = gMessageStringTable.getString("FailedResends"); + _PREHASH_SecPerDay = gMessageStringTable.getString("SecPerDay"); _PREHASH_CameraCenter = gMessageStringTable.getString("CameraCenter"); _PREHASH_CameraLeftAxis = gMessageStringTable.getString("CameraLeftAxis"); _PREHASH_ExBlock = gMessageStringTable.getString("ExBlock"); @@ -1733,7 +1588,6 @@ void init_prehash_data() _PREHASH_NetTest = gMessageStringTable.getString("NetTest"); _PREHASH_DiscardLevel = gMessageStringTable.getString("DiscardLevel"); _PREHASH_LayerID = gMessageStringTable.getString("LayerID"); - _PREHASH_RatorID = gMessageStringTable.getString("RatorID"); _PREHASH_GrabOffset = gMessageStringTable.getString("GrabOffset"); _PREHASH_SimPort = gMessageStringTable.getString("SimPort"); _PREHASH_PricePerMeter = gMessageStringTable.getString("PricePerMeter"); @@ -1753,21 +1607,16 @@ void init_prehash_data() _PREHASH_RegionsVisited = gMessageStringTable.getString("RegionsVisited"); _PREHASH_DirClassifiedReply = gMessageStringTable.getString("DirClassifiedReply"); _PREHASH_AvatarClassifiedReply = gMessageStringTable.getString("AvatarClassifiedReply"); - _PREHASH_ReputationIndividualReply = gMessageStringTable.getString("ReputationIndividualReply"); _PREHASH_MediaURL = gMessageStringTable.getString("MediaURL"); _PREHASH_CompleteAgentMovement = gMessageStringTable.getString("CompleteAgentMovement"); - _PREHASH_SpaceIP = gMessageStringTable.getString("SpaceIP"); _PREHASH_ClassifiedID = gMessageStringTable.getString("ClassifiedID"); _PREHASH_LocalID = gMessageStringTable.getString("LocalID"); + _PREHASH_SpaceIP = gMessageStringTable.getString("SpaceIP"); _PREHASH_RemoveItem = gMessageStringTable.getString("RemoveItem"); _PREHASH_LogFailedMoneyTransaction = gMessageStringTable.getString("LogFailedMoneyTransaction"); _PREHASH_ViewerStartAuction = gMessageStringTable.getString("ViewerStartAuction"); _PREHASH_StartAuction = gMessageStringTable.getString("StartAuction"); - _PREHASH_NameValueName = gMessageStringTable.getString("NameValueName"); - _PREHASH_AngVelX = gMessageStringTable.getString("AngVelX"); _PREHASH_DuplicateFlags = gMessageStringTable.getString("DuplicateFlags"); - _PREHASH_AngVelY = gMessageStringTable.getString("AngVelY"); - _PREHASH_AngVelZ = gMessageStringTable.getString("AngVelZ"); _PREHASH_TextColor = gMessageStringTable.getString("TextColor"); _PREHASH_SlaveID = gMessageStringTable.getString("SlaveID"); _PREHASH_Charter = gMessageStringTable.getString("Charter"); @@ -1778,21 +1627,16 @@ void init_prehash_data() _PREHASH_OwnerIsGroup = gMessageStringTable.getString("OwnerIsGroup"); _PREHASH_NameValuePair = gMessageStringTable.getString("NameValuePair"); _PREHASH_RemoveNameValuePair = gMessageStringTable.getString("RemoveNameValuePair"); - _PREHASH_GetNameValuePair = gMessageStringTable.getString("GetNameValuePair"); _PREHASH_BulkUpdateInventory = gMessageStringTable.getString("BulkUpdateInventory"); _PREHASH_UpdateTaskInventory = gMessageStringTable.getString("UpdateTaskInventory"); _PREHASH_RemoveTaskInventory = gMessageStringTable.getString("RemoveTaskInventory"); _PREHASH_MoveTaskInventory = gMessageStringTable.getString("MoveTaskInventory"); _PREHASH_RequestTaskInventory = gMessageStringTable.getString("RequestTaskInventory"); _PREHASH_ReplyTaskInventory = gMessageStringTable.getString("ReplyTaskInventory"); - _PREHASH_DeclineInventory = gMessageStringTable.getString("DeclineInventory"); _PREHASH_AggregatePermInventory = gMessageStringTable.getString("AggregatePermInventory"); - _PREHASH_SimulatorInfo = gMessageStringTable.getString("SimulatorInfo"); - _PREHASH_MoneyTransactionsReply = gMessageStringTable.getString("MoneyTransactionsReply"); _PREHASH_GroupAccountTransactionsReply = gMessageStringTable.getString("GroupAccountTransactionsReply"); - _PREHASH_MailTaskSimReply = gMessageStringTable.getString("MailTaskSimReply"); + _PREHASH_SimulatorInfo = gMessageStringTable.getString("SimulatorInfo"); _PREHASH_WearableData = gMessageStringTable.getString("WearableData"); - _PREHASH_StatisticsData = gMessageStringTable.getString("StatisticsData"); _PREHASH_Enabled = gMessageStringTable.getString("Enabled"); _PREHASH_Savings = gMessageStringTable.getString("Savings"); _PREHASH_SimulatorLoad = gMessageStringTable.getString("SimulatorLoad"); @@ -1804,15 +1648,12 @@ void init_prehash_data() _PREHASH_LeaveGroupRequest = gMessageStringTable.getString("LeaveGroupRequest"); _PREHASH_InviteGroupRequest = gMessageStringTable.getString("InviteGroupRequest"); _PREHASH_LiveHelpGroupRequest = gMessageStringTable.getString("LiveHelpGroupRequest"); - _PREHASH_ServerVersion = gMessageStringTable.getString("ServerVersion"); _PREHASH_PriceParcelClaimFactor = gMessageStringTable.getString("PriceParcelClaimFactor"); _PREHASH_BillableArea = gMessageStringTable.getString("BillableArea"); _PREHASH_ObjectID = gMessageStringTable.getString("ObjectID"); _PREHASH_ObjectFlagUpdate = gMessageStringTable.getString("ObjectFlagUpdate"); _PREHASH_GroupRoleUpdate = gMessageStringTable.getString("GroupRoleUpdate"); _PREHASH_RequestInventoryAsset = gMessageStringTable.getString("RequestInventoryAsset"); - _PREHASH_RedoLand = gMessageStringTable.getString("RedoLand"); - _PREHASH_TravelAccess = gMessageStringTable.getString("TravelAccess"); _PREHASH_ChangedGrid = gMessageStringTable.getString("ChangedGrid"); _PREHASH_AgentDropGroup = gMessageStringTable.getString("AgentDropGroup"); _PREHASH_Details = gMessageStringTable.getString("Details"); @@ -1845,7 +1686,6 @@ void init_prehash_data() _PREHASH_GlobalPos = gMessageStringTable.getString("GlobalPos"); _PREHASH_GrabOffsetInitial = gMessageStringTable.getString("GrabOffsetInitial"); _PREHASH_IsTrial = gMessageStringTable.getString("IsTrial"); - _PREHASH_FinalizeLogout = gMessageStringTable.getString("FinalizeLogout"); _PREHASH_ObjectDuplicateOnRay = gMessageStringTable.getString("ObjectDuplicateOnRay"); _PREHASH_GroupMembershipCount = gMessageStringTable.getString("GroupMembershipCount"); _PREHASH_MethodData = gMessageStringTable.getString("MethodData"); @@ -1881,32 +1721,26 @@ void init_prehash_data() _PREHASH_SimWideMaxPrims = gMessageStringTable.getString("SimWideMaxPrims"); _PREHASH_TotalPrims = gMessageStringTable.getString("TotalPrims"); _PREHASH_ProfileBegin = gMessageStringTable.getString("ProfileBegin"); - _PREHASH_MoneyDetailsRequest = gMessageStringTable.getString("MoneyDetailsRequest"); _PREHASH_Request = gMessageStringTable.getString("Request"); _PREHASH_GroupAccountDetailsRequest = gMessageStringTable.getString("GroupAccountDetailsRequest"); _PREHASH_GroupActiveProposalsRequest = gMessageStringTable.getString("GroupActiveProposalsRequest"); _PREHASH_StringValue = gMessageStringTable.getString("StringValue"); - _PREHASH_ClosestSimulator = gMessageStringTable.getString("ClosestSimulator"); _PREHASH_Version = gMessageStringTable.getString("Version"); _PREHASH_OtherCount = gMessageStringTable.getString("OtherCount"); _PREHASH_MemberCount = gMessageStringTable.getString("MemberCount"); _PREHASH_ChatData = gMessageStringTable.getString("ChatData"); _PREHASH_IsGroupOwned = gMessageStringTable.getString("IsGroupOwned"); _PREHASH_EnergyEfficiency = gMessageStringTable.getString("EnergyEfficiency"); - _PREHASH_MaxPlace = gMessageStringTable.getString("MaxPlace"); _PREHASH_PickInfoUpdate = gMessageStringTable.getString("PickInfoUpdate"); _PREHASH_PickDelete = gMessageStringTable.getString("PickDelete"); _PREHASH_ScriptReset = gMessageStringTable.getString("ScriptReset"); _PREHASH_Requester = gMessageStringTable.getString("Requester"); _PREHASH_ForSale = gMessageStringTable.getString("ForSale"); _PREHASH_NearestLandingRegionReply = gMessageStringTable.getString("NearestLandingRegionReply"); - _PREHASH_RecordAgentPresence = gMessageStringTable.getString("RecordAgentPresence"); - _PREHASH_EraseAgentPresence = gMessageStringTable.getString("EraseAgentPresence"); _PREHASH_ParcelID = gMessageStringTable.getString("ParcelID"); _PREHASH_Godlike = gMessageStringTable.getString("Godlike"); _PREHASH_TotalDebits = gMessageStringTable.getString("TotalDebits"); _PREHASH_Direction = gMessageStringTable.getString("Direction"); - _PREHASH_Appearance = gMessageStringTable.getString("Appearance"); _PREHASH_HealthData = gMessageStringTable.getString("HealthData"); _PREHASH_LeftAxis = gMessageStringTable.getString("LeftAxis"); _PREHASH_LocationBlock = gMessageStringTable.getString("LocationBlock"); @@ -1914,41 +1748,31 @@ void init_prehash_data() _PREHASH_TerrainStartHeight00 = gMessageStringTable.getString("TerrainStartHeight00"); _PREHASH_TerrainStartHeight01 = gMessageStringTable.getString("TerrainStartHeight01"); _PREHASH_TerrainStartHeight10 = gMessageStringTable.getString("TerrainStartHeight10"); - _PREHASH_ObjectHinge = gMessageStringTable.getString("ObjectHinge"); _PREHASH_TerrainStartHeight11 = gMessageStringTable.getString("TerrainStartHeight11"); - _PREHASH_MetersPerGrid = gMessageStringTable.getString("MetersPerGrid"); _PREHASH_WaterHeight = gMessageStringTable.getString("WaterHeight"); _PREHASH_FetchInventoryReply = gMessageStringTable.getString("FetchInventoryReply"); - _PREHASH_MoneySummaryReply = gMessageStringTable.getString("MoneySummaryReply"); _PREHASH_GroupAccountSummaryReply = gMessageStringTable.getString("GroupAccountSummaryReply"); _PREHASH_AttachedSound = gMessageStringTable.getString("AttachedSound"); _PREHASH_ParamInUse = gMessageStringTable.getString("ParamInUse"); _PREHASH_GodKickUser = gMessageStringTable.getString("GodKickUser"); _PREHASH_PickName = gMessageStringTable.getString("PickName"); _PREHASH_TaskName = gMessageStringTable.getString("TaskName"); - _PREHASH_SubType = gMessageStringTable.getString("SubType"); _PREHASH_ObjectCount = gMessageStringTable.getString("ObjectCount"); _PREHASH_RegionPresenceRequestByHandle = gMessageStringTable.getString("RegionPresenceRequestByHandle"); _PREHASH_RezSingleAttachmentFromInv = gMessageStringTable.getString("RezSingleAttachmentFromInv"); _PREHASH_ChildAgentUpdate = gMessageStringTable.getString("ChildAgentUpdate"); - _PREHASH_ToID = gMessageStringTable.getString("ToID"); - _PREHASH_ViewerPort = gMessageStringTable.getString("ViewerPort"); _PREHASH_IsOwnerGroup = gMessageStringTable.getString("IsOwnerGroup"); _PREHASH_AgentHeightWidth = gMessageStringTable.getString("AgentHeightWidth"); _PREHASH_VerticalAngle = gMessageStringTable.getString("VerticalAngle"); _PREHASH_WearableType = gMessageStringTable.getString("WearableType"); _PREHASH_AggregatePermNextOwner = gMessageStringTable.getString("AggregatePermNextOwner"); _PREHASH_ShowInList = gMessageStringTable.getString("ShowInList"); - _PREHASH_PositionSuggestion = gMessageStringTable.getString("PositionSuggestion"); _PREHASH_UpdateParcel = gMessageStringTable.getString("UpdateParcel"); - _PREHASH_ClearAgentSessions = gMessageStringTable.getString("ClearAgentSessions"); _PREHASH_SetAlwaysRun = gMessageStringTable.getString("SetAlwaysRun"); _PREHASH_NVPair = gMessageStringTable.getString("NVPair"); _PREHASH_SearchType = gMessageStringTable.getString("SearchType"); _PREHASH_ObjectSpinStart = gMessageStringTable.getString("ObjectSpinStart"); _PREHASH_UseEstateSun = gMessageStringTable.getString("UseEstateSun"); - _PREHASH_LogoutBlock = gMessageStringTable.getString("LogoutBlock"); - _PREHASH_RelayLogControl = gMessageStringTable.getString("RelayLogControl"); _PREHASH_RegionID = gMessageStringTable.getString("RegionID"); _PREHASH_AbuseRegionID = gMessageStringTable.getString("AbuseRegionID"); _PREHASH_Creator = gMessageStringTable.getString("Creator"); @@ -1957,14 +1781,12 @@ void init_prehash_data() _PREHASH_EventInfoReply = gMessageStringTable.getString("EventInfoReply"); _PREHASH_UserInfoReply = gMessageStringTable.getString("UserInfoReply"); _PREHASH_PathRadiusOffset = gMessageStringTable.getString("PathRadiusOffset"); - _PREHASH_SessionInfo = gMessageStringTable.getString("SessionInfo"); _PREHASH_TextureData = gMessageStringTable.getString("TextureData"); _PREHASH_ChatPass = gMessageStringTable.getString("ChatPass"); _PREHASH_TargetID = gMessageStringTable.getString("TargetID"); _PREHASH_DefaultPayPrice = gMessageStringTable.getString("DefaultPayPrice"); _PREHASH_UserLocation = gMessageStringTable.getString("UserLocation"); _PREHASH_MaxPrims = gMessageStringTable.getString("MaxPrims"); - _PREHASH_RegionIP = gMessageStringTable.getString("RegionIP"); _PREHASH_LandmarkID = gMessageStringTable.getString("LandmarkID"); _PREHASH_InitiateDownload = gMessageStringTable.getString("InitiateDownload"); _PREHASH_Name = gMessageStringTable.getString("Name"); @@ -1972,18 +1794,13 @@ void init_prehash_data() _PREHASH_ParcelSetOtherCleanTime = gMessageStringTable.getString("ParcelSetOtherCleanTime"); _PREHASH_TeleportPriceExponent = gMessageStringTable.getString("TeleportPriceExponent"); _PREHASH_Gain = gMessageStringTable.getString("Gain"); - _PREHASH_VelX = gMessageStringTable.getString("VelX"); _PREHASH_PacketAck = gMessageStringTable.getString("PacketAck"); _PREHASH_PathSkew = gMessageStringTable.getString("PathSkew"); - _PREHASH_Negative = gMessageStringTable.getString("Negative"); - _PREHASH_VelY = gMessageStringTable.getString("VelY"); _PREHASH_SimulatorShutdownRequest = gMessageStringTable.getString("SimulatorShutdownRequest"); _PREHASH_NearestLandingRegionRequest = gMessageStringTable.getString("NearestLandingRegionRequest"); - _PREHASH_VelZ = gMessageStringTable.getString("VelZ"); _PREHASH_OtherID = gMessageStringTable.getString("OtherID"); _PREHASH_MemberID = gMessageStringTable.getString("MemberID"); _PREHASH_MapLayerRequest = gMessageStringTable.getString("MapLayerRequest"); - _PREHASH_PatchVersion = gMessageStringTable.getString("PatchVersion"); _PREHASH_ObjectScale = gMessageStringTable.getString("ObjectScale"); _PREHASH_TargetIP = gMessageStringTable.getString("TargetIP"); _PREHASH_Redo = gMessageStringTable.getString("Redo"); @@ -2026,27 +1843,20 @@ void init_prehash_data() _PREHASH_Code = gMessageStringTable.getString("Code"); _PREHASH_InvType = gMessageStringTable.getString("InvType"); _PREHASH_AgentFOV = gMessageStringTable.getString("AgentFOV"); - _PREHASH_BulkMoneyTransfer = gMessageStringTable.getString("BulkMoneyTransfer"); _PREHASH_Audible = gMessageStringTable.getString("Audible"); _PREHASH_AuctionData = gMessageStringTable.getString("AuctionData"); _PREHASH_IDBlock = gMessageStringTable.getString("IDBlock"); - _PREHASH_ReputationData = gMessageStringTable.getString("ReputationData"); _PREHASH_West = gMessageStringTable.getString("West"); _PREHASH_Undo = gMessageStringTable.getString("Undo"); _PREHASH_TotalNumItems = gMessageStringTable.getString("TotalNumItems"); _PREHASH_Info = gMessageStringTable.getString("Info"); _PREHASH_Area = gMessageStringTable.getString("Area"); - _PREHASH_Behavior = gMessageStringTable.getString("Behavior"); _PREHASH_SimCrashed = gMessageStringTable.getString("SimCrashed"); _PREHASH_Text = gMessageStringTable.getString("Text"); - _PREHASH_AgentToNewRegion = gMessageStringTable.getString("AgentToNewRegion"); _PREHASH_PriceGroupCreate = gMessageStringTable.getString("PriceGroupCreate"); _PREHASH_ObjectShape = gMessageStringTable.getString("ObjectShape"); _PREHASH_GroupRoleDataReply = gMessageStringTable.getString("GroupRoleDataReply"); - _PREHASH_PosX = gMessageStringTable.getString("PosX"); - _PREHASH_PosY = gMessageStringTable.getString("PosY"); _PREHASH_MuteCRC = gMessageStringTable.getString("MuteCRC"); - _PREHASH_PosZ = gMessageStringTable.getString("PosZ"); _PREHASH_Size = gMessageStringTable.getString("Size"); _PREHASH_FromAddress = gMessageStringTable.getString("FromAddress"); _PREHASH_Body = gMessageStringTable.getString("Body"); @@ -2064,16 +1874,14 @@ void init_prehash_data() _PREHASH_SoundID = gMessageStringTable.getString("SoundID"); _PREHASH_Item = gMessageStringTable.getString("Item"); _PREHASH_User = gMessageStringTable.getString("User"); - _PREHASH_RemoteInfos = gMessageStringTable.getString("RemoteInfos"); _PREHASH_Prey = gMessageStringTable.getString("Prey"); - _PREHASH_UsecSinceStart = gMessageStringTable.getString("UsecSinceStart"); _PREHASH_RayStart = gMessageStringTable.getString("RayStart"); + _PREHASH_UsecSinceStart = gMessageStringTable.getString("UsecSinceStart"); _PREHASH_ParcelData = gMessageStringTable.getString("ParcelData"); _PREHASH_CameraUpAxis = gMessageStringTable.getString("CameraUpAxis"); _PREHASH_ScriptDialog = gMessageStringTable.getString("ScriptDialog"); _PREHASH_MasterParcelData = gMessageStringTable.getString("MasterParcelData"); _PREHASH_Invalid = gMessageStringTable.getString("Invalid"); - _PREHASH_MinPlace = gMessageStringTable.getString("MinPlace"); _PREHASH_ProfileCurve = gMessageStringTable.getString("ProfileCurve"); _PREHASH_ParcelAccessListUpdate = gMessageStringTable.getString("ParcelAccessListUpdate"); _PREHASH_MuteListUpdate = gMessageStringTable.getString("MuteListUpdate"); @@ -2092,14 +1900,12 @@ void init_prehash_data() _PREHASH_IsTemporary = gMessageStringTable.getString("IsTemporary"); _PREHASH_InsigniaID = gMessageStringTable.getString("InsigniaID"); _PREHASH_CheckFlags = gMessageStringTable.getString("CheckFlags"); - _PREHASH_TransferPriority = gMessageStringTable.getString("TransferPriority"); _PREHASH_EventID = gMessageStringTable.getString("EventID"); _PREHASH_Selected = gMessageStringTable.getString("Selected"); _PREHASH_FromAgentId = gMessageStringTable.getString("FromAgentId"); _PREHASH_Type = gMessageStringTable.getString("Type"); _PREHASH_ChatType = gMessageStringTable.getString("ChatType"); _PREHASH_ReportData = gMessageStringTable.getString("ReportData"); - _PREHASH_LeaderBoardData = gMessageStringTable.getString("LeaderBoardData"); _PREHASH_RequestBlock = gMessageStringTable.getString("RequestBlock"); _PREHASH_GrantData = gMessageStringTable.getString("GrantData"); _PREHASH_DetachAttachmentIntoInv = gMessageStringTable.getString("DetachAttachmentIntoInv"); @@ -2115,12 +1921,9 @@ void init_prehash_data() _PREHASH_OfflineNotification = gMessageStringTable.getString("OfflineNotification"); _PREHASH_SendPostcard = gMessageStringTable.getString("SendPostcard"); _PREHASH_RequestFlags = gMessageStringTable.getString("RequestFlags"); - _PREHASH_MoneyHistoryRequest = gMessageStringTable.getString("MoneyHistoryRequest"); - _PREHASH_MoneySummaryRequest = gMessageStringTable.getString("MoneySummaryRequest"); _PREHASH_GroupAccountSummaryRequest = gMessageStringTable.getString("GroupAccountSummaryRequest"); _PREHASH_GroupVoteHistoryRequest = gMessageStringTable.getString("GroupVoteHistoryRequest"); _PREHASH_ParamValue = gMessageStringTable.getString("ParamValue"); - _PREHASH_Checksum = gMessageStringTable.getString("Checksum"); _PREHASH_MaxAgents = gMessageStringTable.getString("MaxAgents"); _PREHASH_CreateNewOutfitAttachments = gMessageStringTable.getString("CreateNewOutfitAttachments"); _PREHASH_RegionHandle = gMessageStringTable.getString("RegionHandle"); @@ -2130,12 +1933,10 @@ void init_prehash_data() _PREHASH_GroupNoticeID = gMessageStringTable.getString("GroupNoticeID"); _PREHASH_ParcelName = gMessageStringTable.getString("ParcelName"); _PREHASH_PriceObjectRent = gMessageStringTable.getString("PriceObjectRent"); - _PREHASH_ConnectAgentToUserserver = gMessageStringTable.getString("ConnectAgentToUserserver"); - _PREHASH_ConnectToUserserver = gMessageStringTable.getString("ConnectToUserserver"); _PREHASH_OfferCallingCard = gMessageStringTable.getString("OfferCallingCard"); - _PREHASH_AgentAccess = gMessageStringTable.getString("AgentAccess"); _PREHASH_AcceptCallingCard = gMessageStringTable.getString("AcceptCallingCard"); _PREHASH_DeclineCallingCard = gMessageStringTable.getString("DeclineCallingCard"); + _PREHASH_AgentAccess = gMessageStringTable.getString("AgentAccess"); _PREHASH_DataHomeLocationReply = gMessageStringTable.getString("DataHomeLocationReply"); _PREHASH_EventLocationReply = gMessageStringTable.getString("EventLocationReply"); _PREHASH_TerseDateID = gMessageStringTable.getString("TerseDateID"); @@ -2153,8 +1954,8 @@ void init_prehash_data() _PREHASH_IntervalDays = gMessageStringTable.getString("IntervalDays"); _PREHASH_PathScaleX = gMessageStringTable.getString("PathScaleX"); _PREHASH_FromTaskID = gMessageStringTable.getString("FromTaskID"); - _PREHASH_TimeInfo = gMessageStringTable.getString("TimeInfo"); _PREHASH_PathScaleY = gMessageStringTable.getString("PathScaleY"); + _PREHASH_TimeInfo = gMessageStringTable.getString("TimeInfo"); _PREHASH_PublicCount = gMessageStringTable.getString("PublicCount"); _PREHASH_ParcelJoin = gMessageStringTable.getString("ParcelJoin"); _PREHASH_GroupRolesCount = gMessageStringTable.getString("GroupRolesCount"); @@ -2179,7 +1980,6 @@ void init_prehash_data() _PREHASH_PassToAgent = gMessageStringTable.getString("PassToAgent"); _PREHASH_PreyAgent = gMessageStringTable.getString("PreyAgent"); _PREHASH_SimStats = gMessageStringTable.getString("SimStats"); - _PREHASH_Options = gMessageStringTable.getString("Options"); _PREHASH_LogoutReply = gMessageStringTable.getString("LogoutReply"); _PREHASH_FeatureDisabled = gMessageStringTable.getString("FeatureDisabled"); _PREHASH_ObjectLocalID = gMessageStringTable.getString("ObjectLocalID"); @@ -2190,10 +1990,8 @@ void init_prehash_data() _PREHASH_MasterID = gMessageStringTable.getString("MasterID"); _PREHASH_TransferData = gMessageStringTable.getString("TransferData"); _PREHASH_WantToMask = gMessageStringTable.getString("WantToMask"); - _PREHASH_AvatarData = gMessageStringTable.getString("AvatarData"); _PREHASH_ParcelSelectObjects = gMessageStringTable.getString("ParcelSelectObjects"); _PREHASH_ExtraParams = gMessageStringTable.getString("ExtraParams"); - _PREHASH_LogLogin = gMessageStringTable.getString("LogLogin"); _PREHASH_CreatorID = gMessageStringTable.getString("CreatorID"); _PREHASH_Summary = gMessageStringTable.getString("Summary"); _PREHASH_BuyObjectInventory = gMessageStringTable.getString("BuyObjectInventory"); @@ -2234,8 +2032,8 @@ void init_prehash_data() _PREHASH_GranterID = gMessageStringTable.getString("GranterID"); _PREHASH_WantToText = gMessageStringTable.getString("WantToText"); _PREHASH_ReportType = gMessageStringTable.getString("ReportType"); - _PREHASH_DataBlock = gMessageStringTable.getString("DataBlock"); _PREHASH_SimulatorReady = gMessageStringTable.getString("SimulatorReady"); + _PREHASH_DataBlock = gMessageStringTable.getString("DataBlock"); _PREHASH_AnimationSourceList = gMessageStringTable.getString("AnimationSourceList"); _PREHASH_SubscribeLoad = gMessageStringTable.getString("SubscribeLoad"); _PREHASH_UnsubscribeLoad = gMessageStringTable.getString("UnsubscribeLoad"); @@ -2262,9 +2060,8 @@ void init_prehash_data() _PREHASH_GestureFlags = gMessageStringTable.getString("GestureFlags"); _PREHASH_XferID = gMessageStringTable.getString("XferID"); _PREHASH_StatValue = gMessageStringTable.getString("StatValue"); - _PREHASH_PickID = gMessageStringTable.getString("PickID"); _PREHASH_TaskID = gMessageStringTable.getString("TaskID"); - _PREHASH_GridsPerEdge = gMessageStringTable.getString("GridsPerEdge"); + _PREHASH_PickID = gMessageStringTable.getString("PickID"); _PREHASH_RayEnd = gMessageStringTable.getString("RayEnd"); _PREHASH_Throttles = gMessageStringTable.getString("Throttles"); _PREHASH_RebakeAvatarTextures = gMessageStringTable.getString("RebakeAvatarTextures"); @@ -2277,30 +2074,24 @@ void init_prehash_data() _PREHASH_TitleRoleID = gMessageStringTable.getString("TitleRoleID"); _PREHASH_SquareMetersCredit = gMessageStringTable.getString("SquareMetersCredit"); _PREHASH_Filename = gMessageStringTable.getString("Filename"); - _PREHASH_SecuredTemplateChecksumRequest = gMessageStringTable.getString("SecuredTemplateChecksumRequest"); - _PREHASH_TemplateChecksumRequest = gMessageStringTable.getString("TemplateChecksumRequest"); - _PREHASH_AgentPresenceRequest = gMessageStringTable.getString("AgentPresenceRequest"); _PREHASH_ClassifiedInfoRequest = gMessageStringTable.getString("ClassifiedInfoRequest"); _PREHASH_ParcelInfoRequest = gMessageStringTable.getString("ParcelInfoRequest"); _PREHASH_ParcelObjectOwnersRequest = gMessageStringTable.getString("ParcelObjectOwnersRequest"); _PREHASH_TeleportLandmarkRequest = gMessageStringTable.getString("TeleportLandmarkRequest"); _PREHASH_EventInfoRequest = gMessageStringTable.getString("EventInfoRequest"); - _PREHASH_ChatFromSimulator = gMessageStringTable.getString("ChatFromSimulator"); - _PREHASH_PickInfoRequest = gMessageStringTable.getString("PickInfoRequest"); _PREHASH_MoneyBalanceRequest = gMessageStringTable.getString("MoneyBalanceRequest"); _PREHASH_GroupMembersRequest = gMessageStringTable.getString("GroupMembersRequest"); _PREHASH_GroupRoleMembersRequest = gMessageStringTable.getString("GroupRoleMembersRequest"); + _PREHASH_ChatFromSimulator = gMessageStringTable.getString("ChatFromSimulator"); _PREHASH_OldFolderID = gMessageStringTable.getString("OldFolderID"); _PREHASH_UserInfoRequest = gMessageStringTable.getString("UserInfoRequest"); _PREHASH_TextureID = gMessageStringTable.getString("TextureID"); _PREHASH_ProfileURL = gMessageStringTable.getString("ProfileURL"); _PREHASH_Handle = gMessageStringTable.getString("Handle"); - _PREHASH_StartParcelRenameAck = gMessageStringTable.getString("StartParcelRenameAck"); _PREHASH_ButtonIndex = gMessageStringTable.getString("ButtonIndex"); _PREHASH_GetScriptRunning = gMessageStringTable.getString("GetScriptRunning"); _PREHASH_SetScriptRunning = gMessageStringTable.getString("SetScriptRunning"); _PREHASH_Health = gMessageStringTable.getString("Health"); - _PREHASH_FileID = gMessageStringTable.getString("FileID"); _PREHASH_CircuitInfo = gMessageStringTable.getString("CircuitInfo"); _PREHASH_ObjectBuy = gMessageStringTable.getString("ObjectBuy"); _PREHASH_ProfileEnd = gMessageStringTable.getString("ProfileEnd"); @@ -2325,7 +2116,6 @@ void init_prehash_data() _PREHASH_Change = gMessageStringTable.getString("Change"); _PREHASH_Height = gMessageStringTable.getString("Height"); _PREHASH_Region = gMessageStringTable.getString("Region"); - _PREHASH_MoneyHistoryReply = gMessageStringTable.getString("MoneyHistoryReply"); _PREHASH_TelehubInfo = gMessageStringTable.getString("TelehubInfo"); _PREHASH_StateSave = gMessageStringTable.getString("StateSave"); _PREHASH_RoleData = gMessageStringTable.getString("RoleData"); @@ -2336,11 +2126,10 @@ void init_prehash_data() _PREHASH_UsePhysics = gMessageStringTable.getString("UsePhysics"); _PREHASH_RegionDenyTransacted = gMessageStringTable.getString("RegionDenyTransacted"); _PREHASH_JointType = gMessageStringTable.getString("JointType"); - _PREHASH_TaxEstimate = gMessageStringTable.getString("TaxEstimate"); _PREHASH_ObjectTaxEstimate = gMessageStringTable.getString("ObjectTaxEstimate"); _PREHASH_LightTaxEstimate = gMessageStringTable.getString("LightTaxEstimate"); - _PREHASH_TeleportLandingStatusChanged = gMessageStringTable.getString("TeleportLandingStatusChanged"); _PREHASH_LandTaxEstimate = gMessageStringTable.getString("LandTaxEstimate"); + _PREHASH_TeleportLandingStatusChanged = gMessageStringTable.getString("TeleportLandingStatusChanged"); _PREHASH_GroupTaxEstimate = gMessageStringTable.getString("GroupTaxEstimate"); _PREHASH_AvgViewerFPS = gMessageStringTable.getString("AvgViewerFPS"); _PREHASH_Buttons = gMessageStringTable.getString("Buttons"); @@ -2372,8 +2161,6 @@ void init_prehash_data() _PREHASH_ChannelType = gMessageStringTable.getString("ChannelType"); _PREHASH_NonExemptMembers = gMessageStringTable.getString("NonExemptMembers"); _PREHASH_Agents = gMessageStringTable.getString("Agents"); - _PREHASH_SimulatorStart = gMessageStringTable.getString("SimulatorStart"); - _PREHASH_Enable = gMessageStringTable.getString("Enable"); _PREHASH_MemberData = gMessageStringTable.getString("MemberData"); _PREHASH_ToGroupID = gMessageStringTable.getString("ToGroupID"); _PREHASH_ImageNotInDatabase = gMessageStringTable.getString("ImageNotInDatabase"); @@ -2381,27 +2168,21 @@ void init_prehash_data() _PREHASH_AnimID = gMessageStringTable.getString("AnimID"); _PREHASH_Serial = gMessageStringTable.getString("Serial"); _PREHASH_AbuseRegionName = gMessageStringTable.getString("AbuseRegionName"); - _PREHASH_ControlPort = gMessageStringTable.getString("ControlPort"); _PREHASH_ModifyLand = gMessageStringTable.getString("ModifyLand"); _PREHASH_Digest = gMessageStringTable.getString("Digest"); _PREHASH_Victim = gMessageStringTable.getString("Victim"); _PREHASH_Script = gMessageStringTable.getString("Script"); - _PREHASH_TemplateChecksumReply = gMessageStringTable.getString("TemplateChecksumReply"); _PREHASH_PickInfoReply = gMessageStringTable.getString("PickInfoReply"); _PREHASH_MoneyBalanceReply = gMessageStringTable.getString("MoneyBalanceReply"); _PREHASH_RoutedMoneyBalanceReply = gMessageStringTable.getString("RoutedMoneyBalanceReply"); _PREHASH_RoleID = gMessageStringTable.getString("RoleID"); _PREHASH_RegionInfo = gMessageStringTable.getString("RegionInfo"); - _PREHASH_Sequence = gMessageStringTable.getString("Sequence"); _PREHASH_GodUpdateRegionInfo = gMessageStringTable.getString("GodUpdateRegionInfo"); - _PREHASH_LocalX = gMessageStringTable.getString("LocalX"); - _PREHASH_LocalY = gMessageStringTable.getString("LocalY"); _PREHASH_StartAnim = gMessageStringTable.getString("StartAnim"); - _PREHASH_Location = gMessageStringTable.getString("Location"); _PREHASH_Action = gMessageStringTable.getString("Action"); + _PREHASH_Location = gMessageStringTable.getString("Location"); _PREHASH_Rights = gMessageStringTable.getString("Rights"); _PREHASH_SearchDir = gMessageStringTable.getString("SearchDir"); - _PREHASH_Active = gMessageStringTable.getString("Active"); _PREHASH_TransferRequest = gMessageStringTable.getString("TransferRequest"); _PREHASH_ScriptSensorRequest = gMessageStringTable.getString("ScriptSensorRequest"); _PREHASH_MoneyTransferRequest = gMessageStringTable.getString("MoneyTransferRequest"); @@ -2412,8 +2193,6 @@ void init_prehash_data() _PREHASH_SharedData = gMessageStringTable.getString("SharedData"); _PREHASH_PSBlock = gMessageStringTable.getString("PSBlock"); _PREHASH_UUIDNameBlock = gMessageStringTable.getString("UUIDNameBlock"); - _PREHASH_Viewer = gMessageStringTable.getString("Viewer"); - _PREHASH_GroupNoticeDelete = gMessageStringTable.getString("GroupNoticeDelete"); _PREHASH_GroupTitleUpdate = gMessageStringTable.getString("GroupTitleUpdate"); _PREHASH_Method = gMessageStringTable.getString("Method"); _PREHASH_TouchName = gMessageStringTable.getString("TouchName"); @@ -2425,11 +2204,9 @@ void init_prehash_data() _PREHASH_SystemMessage = gMessageStringTable.getString("SystemMessage"); _PREHASH_BodyRotation = gMessageStringTable.getString("BodyRotation"); _PREHASH_SearchRegions = gMessageStringTable.getString("SearchRegions"); - _PREHASH_Ignore = gMessageStringTable.getString("Ignore"); _PREHASH_AnimationData = gMessageStringTable.getString("AnimationData"); _PREHASH_StatID = gMessageStringTable.getString("StatID"); _PREHASH_ItemID = gMessageStringTable.getString("ItemID"); - _PREHASH_AvatarStatisticsReply = gMessageStringTable.getString("AvatarStatisticsReply"); _PREHASH_ScriptDialogReply = gMessageStringTable.getString("ScriptDialogReply"); _PREHASH_RegionIDAndHandleReply = gMessageStringTable.getString("RegionIDAndHandleReply"); _PREHASH_CameraAtOffset = gMessageStringTable.getString("CameraAtOffset"); @@ -2454,7 +2231,6 @@ void init_prehash_data() _PREHASH_RegionPort = gMessageStringTable.getString("RegionPort"); _PREHASH_PriceEnergyUnit = gMessageStringTable.getString("PriceEnergyUnit"); _PREHASH_Bitmap = gMessageStringTable.getString("Bitmap"); - _PREHASH_TrackAgentSession = gMessageStringTable.getString("TrackAgentSession"); _PREHASH_CacheMissType = gMessageStringTable.getString("CacheMissType"); _PREHASH_VFileID = gMessageStringTable.getString("VFileID"); _PREHASH_GroupInsigniaID = gMessageStringTable.getString("GroupInsigniaID"); @@ -2502,7 +2278,6 @@ void init_prehash_data() _PREHASH_CanAcceptTasks = gMessageStringTable.getString("CanAcceptTasks"); _PREHASH_ItemData = gMessageStringTable.getString("ItemData"); _PREHASH_AnimationList = gMessageStringTable.getString("AnimationList"); - _PREHASH_PassObject = gMessageStringTable.getString("PassObject"); _PREHASH_Reputation = gMessageStringTable.getString("Reputation"); _PREHASH_IntValue = gMessageStringTable.getString("IntValue"); _PREHASH_TargetType = gMessageStringTable.getString("TargetType"); @@ -2525,10 +2300,8 @@ void init_prehash_data() _PREHASH_DirFindQueryBackend = gMessageStringTable.getString("DirFindQueryBackend"); _PREHASH_DirPlacesQueryBackend = gMessageStringTable.getString("DirPlacesQueryBackend"); _PREHASH_DirClassifiedQueryBackend = gMessageStringTable.getString("DirClassifiedQueryBackend"); - _PREHASH_DirPicksQueryBackend = gMessageStringTable.getString("DirPicksQueryBackend"); _PREHASH_DirLandQueryBackend = gMessageStringTable.getString("DirLandQueryBackend"); _PREHASH_DirPopularQueryBackend = gMessageStringTable.getString("DirPopularQueryBackend"); - _PREHASH_LogoutDemand = gMessageStringTable.getString("LogoutDemand"); _PREHASH_HistoryData = gMessageStringTable.getString("HistoryData"); _PREHASH_SnapshotID = gMessageStringTable.getString("SnapshotID"); _PREHASH_Aspect = gMessageStringTable.getString("Aspect"); @@ -2536,7 +2309,6 @@ void init_prehash_data() _PREHASH_VoteCast = gMessageStringTable.getString("VoteCast"); _PREHASH_CastsShadows = gMessageStringTable.getString("CastsShadows"); _PREHASH_EveryoneMask = gMessageStringTable.getString("EveryoneMask"); - _PREHASH_SetSunPhase = gMessageStringTable.getString("SetSunPhase"); _PREHASH_ObjectSpinUpdate = gMessageStringTable.getString("ObjectSpinUpdate"); _PREHASH_MaturePublish = gMessageStringTable.getString("MaturePublish"); _PREHASH_UseExistingAsset = gMessageStringTable.getString("UseExistingAsset"); @@ -2545,7 +2317,6 @@ void init_prehash_data() _PREHASH_TeleportCancel = gMessageStringTable.getString("TeleportCancel"); _PREHASH_UnixTime = gMessageStringTable.getString("UnixTime"); _PREHASH_QueryFlags = gMessageStringTable.getString("QueryFlags"); - _PREHASH_LastExecFroze = gMessageStringTable.getString("LastExecFroze"); _PREHASH_AlwaysRun = gMessageStringTable.getString("AlwaysRun"); _PREHASH_Bottom = gMessageStringTable.getString("Bottom"); _PREHASH_ButtonData = gMessageStringTable.getString("ButtonData"); @@ -2564,7 +2335,6 @@ void init_prehash_data() _PREHASH_GroupNoticesListRequest = gMessageStringTable.getString("GroupNoticesListRequest"); _PREHASH_ParcelAccessListRequest = gMessageStringTable.getString("ParcelAccessListRequest"); _PREHASH_MuteListRequest = gMessageStringTable.getString("MuteListRequest"); - _PREHASH_StartPeriod = gMessageStringTable.getString("StartPeriod"); _PREHASH_RpcChannelRequest = gMessageStringTable.getString("RpcChannelRequest"); _PREHASH_LandStatRequest = gMessageStringTable.getString("LandStatRequest"); _PREHASH_PlacesQuery = gMessageStringTable.getString("PlacesQuery"); @@ -2592,34 +2362,27 @@ void init_prehash_data() _PREHASH_SoundTrigger = gMessageStringTable.getString("SoundTrigger"); _PREHASH_TerrainRaiseLimit = gMessageStringTable.getString("TerrainRaiseLimit"); _PREHASH_Quorum = gMessageStringTable.getString("Quorum"); - _PREHASH_TokenBlock = gMessageStringTable.getString("TokenBlock"); _PREHASH_AgentBlock = gMessageStringTable.getString("AgentBlock"); _PREHASH_CommandBlock = gMessageStringTable.getString("CommandBlock"); _PREHASH_PricePublicObjectDecay = gMessageStringTable.getString("PricePublicObjectDecay"); _PREHASH_SpawnPointPos = gMessageStringTable.getString("SpawnPointPos"); - _PREHASH_AttachedSoundCutoffRadius = gMessageStringTable.getString("AttachedSoundCutoffRadius"); _PREHASH_VolumeDetail = gMessageStringTable.getString("VolumeDetail"); _PREHASH_FromAgentName = gMessageStringTable.getString("FromAgentName"); _PREHASH_Range = gMessageStringTable.getString("Range"); _PREHASH_DirectoryVisibility = gMessageStringTable.getString("DirectoryVisibility"); _PREHASH_PublicIP = gMessageStringTable.getString("PublicIP"); _PREHASH_TeleportFailed = gMessageStringTable.getString("TeleportFailed"); - _PREHASH_OnlineStatusReply = gMessageStringTable.getString("OnlineStatusReply"); - _PREHASH_RequestAvatarInfo = gMessageStringTable.getString("RequestAvatarInfo"); _PREHASH_PreloadSound = gMessageStringTable.getString("PreloadSound"); _PREHASH_ScreenshotID = gMessageStringTable.getString("ScreenshotID"); _PREHASH_CovenantTimestamp = gMessageStringTable.getString("CovenantTimestamp"); _PREHASH_OldestUnacked = gMessageStringTable.getString("OldestUnacked"); _PREHASH_SimulatorIP = gMessageStringTable.getString("SimulatorIP"); - _PREHASH_ObjectImport = gMessageStringTable.getString("ObjectImport"); _PREHASH_Value = gMessageStringTable.getString("Value"); _PREHASH_JointAxisOrAnchor = gMessageStringTable.getString("JointAxisOrAnchor"); _PREHASH_Test0 = gMessageStringTable.getString("Test0"); _PREHASH_Test1 = gMessageStringTable.getString("Test1"); _PREHASH_Test2 = gMessageStringTable.getString("Test2"); _PREHASH_SunPhase = gMessageStringTable.getString("SunPhase"); - _PREHASH_Place = gMessageStringTable.getString("Place"); - _PREHASH_Phase = gMessageStringTable.getString("Phase"); _PREHASH_ParcelDivide = gMessageStringTable.getString("ParcelDivide"); _PREHASH_PriceObjectClaim = gMessageStringTable.getString("PriceObjectClaim"); _PREHASH_Field = gMessageStringTable.getString("Field"); @@ -2629,7 +2392,6 @@ void init_prehash_data() _PREHASH_Score = gMessageStringTable.getString("Score"); _PREHASH_Image = gMessageStringTable.getString("Image"); _PREHASH_ObjectClickAction = gMessageStringTable.getString("ObjectClickAction"); - _PREHASH_Delta = gMessageStringTable.getString("Delta"); _PREHASH_Parameter = gMessageStringTable.getString("Parameter"); _PREHASH_Flags = gMessageStringTable.getString("Flags"); _PREHASH_Plane = gMessageStringTable.getString("Plane"); @@ -2639,26 +2401,24 @@ void init_prehash_data() _PREHASH_Textures = gMessageStringTable.getString("Textures"); _PREHASH_EventData = gMessageStringTable.getString("EventData"); _PREHASH_Final = gMessageStringTable.getString("Final"); + _PREHASH_System = gMessageStringTable.getString("System"); _PREHASH_TelehubPos = gMessageStringTable.getString("TelehubPos"); _PREHASH_ReportAutosaveCrash = gMessageStringTable.getString("ReportAutosaveCrash"); _PREHASH_CreateTrustedCircuit = gMessageStringTable.getString("CreateTrustedCircuit"); _PREHASH_DenyTrustedCircuit = gMessageStringTable.getString("DenyTrustedCircuit"); _PREHASH_RequestTrustedCircuit = gMessageStringTable.getString("RequestTrustedCircuit"); _PREHASH_Codec = gMessageStringTable.getString("Codec"); - _PREHASH_Level = gMessageStringTable.getString("Level"); _PREHASH_Modal = gMessageStringTable.getString("Modal"); _PREHASH_ChildAgentUnknown = gMessageStringTable.getString("ChildAgentUnknown"); _PREHASH_LandingType = gMessageStringTable.getString("LandingType"); _PREHASH_ScriptRunningReply = gMessageStringTable.getString("ScriptRunningReply"); - _PREHASH_MoneyDetailsReply = gMessageStringTable.getString("MoneyDetailsReply"); _PREHASH_Reply = gMessageStringTable.getString("Reply"); + _PREHASH_GroupAccountDetailsReply = gMessageStringTable.getString("GroupAccountDetailsReply"); _PREHASH_TelehubRot = gMessageStringTable.getString("TelehubRot"); - _PREHASH_RequestFriendship = gMessageStringTable.getString("RequestFriendship"); _PREHASH_AcceptFriendship = gMessageStringTable.getString("AcceptFriendship"); - _PREHASH_GroupAccountDetailsReply = gMessageStringTable.getString("GroupAccountDetailsReply"); + _PREHASH_ItemType = gMessageStringTable.getString("ItemType"); _PREHASH_DwellInfo = gMessageStringTable.getString("DwellInfo"); _PREHASH_AgentResume = gMessageStringTable.getString("AgentResume"); - _PREHASH_ItemType = gMessageStringTable.getString("ItemType"); _PREHASH_MailFilter = gMessageStringTable.getString("MailFilter"); _PREHASH_Disconnect = gMessageStringTable.getString("Disconnect"); _PREHASH_SimPosition = gMessageStringTable.getString("SimPosition"); @@ -2685,7 +2445,6 @@ void init_prehash_data() _PREHASH_CategoryID = gMessageStringTable.getString("CategoryID"); _PREHASH_Token = gMessageStringTable.getString("Token"); _PREHASH_AggregatePerms = gMessageStringTable.getString("AggregatePerms"); - _PREHASH_StartParcelRemoveAck = gMessageStringTable.getString("StartParcelRemoveAck"); _PREHASH_ObjectSelect = gMessageStringTable.getString("ObjectSelect"); _PREHASH_ForceObjectSelect = gMessageStringTable.getString("ForceObjectSelect"); _PREHASH_Price = gMessageStringTable.getString("Price"); @@ -2714,7 +2473,6 @@ void init_prehash_data() _PREHASH_AvatarID = gMessageStringTable.getString("AvatarID"); _PREHASH_FounderID = gMessageStringTable.getString("FounderID"); _PREHASH_EndPointID = gMessageStringTable.getString("EndPointID"); - _PREHASH_StipendEstimate = gMessageStringTable.getString("StipendEstimate"); _PREHASH_LocationLookAt = gMessageStringTable.getString("LocationLookAt"); _PREHASH_Sound = gMessageStringTable.getString("Sound"); _PREHASH_Cover = gMessageStringTable.getString("Cover"); @@ -2734,12 +2492,12 @@ void init_prehash_data() _PREHASH_GroupRoleChanges = gMessageStringTable.getString("GroupRoleChanges"); _PREHASH_Count = gMessageStringTable.getString("Count"); _PREHASH_South = gMessageStringTable.getString("South"); - _PREHASH_Entry = gMessageStringTable.getString("Entry"); _PREHASH_ObjectUpdateCompressed = gMessageStringTable.getString("ObjectUpdateCompressed"); _PREHASH_MuteFlags = gMessageStringTable.getString("MuteFlags"); _PREHASH_Group = gMessageStringTable.getString("Group"); _PREHASH_AgentPause = gMessageStringTable.getString("AgentPause"); _PREHASH_LanguagesText = gMessageStringTable.getString("LanguagesText"); + _PREHASH_Error = gMessageStringTable.getString("Error"); _PREHASH_InternalScriptMail = gMessageStringTable.getString("InternalScriptMail"); _PREHASH_FindAgent = gMessageStringTable.getString("FindAgent"); _PREHASH_AgentData = gMessageStringTable.getString("AgentData"); @@ -2748,7 +2506,6 @@ void init_prehash_data() _PREHASH_AcceptNotices = gMessageStringTable.getString("AcceptNotices"); _PREHASH_SetGroupAcceptNotices = gMessageStringTable.getString("SetGroupAcceptNotices"); _PREHASH_CloseCircuit = gMessageStringTable.getString("CloseCircuit"); - _PREHASH_LogControl = gMessageStringTable.getString("LogControl"); _PREHASH_TeleportFinish = gMessageStringTable.getString("TeleportFinish"); _PREHASH_PathRevolutions = gMessageStringTable.getString("PathRevolutions"); _PREHASH_ClassifiedInfoReply = gMessageStringTable.getString("ClassifiedInfoReply"); @@ -2765,7 +2522,6 @@ void init_prehash_data() _PREHASH_EventNotificationAddRequest = gMessageStringTable.getString("EventNotificationAddRequest"); _PREHASH_ParcelDwellRequest = gMessageStringTable.getString("ParcelDwellRequest"); _PREHASH_EventLocationRequest = gMessageStringTable.getString("EventLocationRequest"); - _PREHASH_EndPeriod = gMessageStringTable.getString("EndPeriod"); _PREHASH_SetStartLocationRequest = gMessageStringTable.getString("SetStartLocationRequest"); _PREHASH_QueryStart = gMessageStringTable.getString("QueryStart"); _PREHASH_EjectData = gMessageStringTable.getString("EjectData"); @@ -2778,7 +2534,6 @@ void init_prehash_data() _PREHASH_VFileType = gMessageStringTable.getString("VFileType"); _PREHASH_EjectGroupMemberReply = gMessageStringTable.getString("EjectGroupMemberReply"); _PREHASH_ImageData = gMessageStringTable.getString("ImageData"); - _PREHASH_SpaceServerSimulatorTimeMessage = gMessageStringTable.getString("SpaceServerSimulatorTimeMessage"); _PREHASH_SimulatorViewerTimeMessage = gMessageStringTable.getString("SimulatorViewerTimeMessage"); _PREHASH_Rotation = gMessageStringTable.getString("Rotation"); _PREHASH_Selection = gMessageStringTable.getString("Selection"); @@ -2786,7 +2541,6 @@ void init_prehash_data() _PREHASH_OperationData = gMessageStringTable.getString("OperationData"); _PREHASH_ExpirationDate = gMessageStringTable.getString("ExpirationDate"); _PREHASH_ParcelDeedToGroup = gMessageStringTable.getString("ParcelDeedToGroup"); - _PREHASH_DirPicksReply = gMessageStringTable.getString("DirPicksReply"); _PREHASH_AvatarPicksReply = gMessageStringTable.getString("AvatarPicksReply"); _PREHASH_GroupTitlesReply = gMessageStringTable.getString("GroupTitlesReply"); _PREHASH_AgentInfo = gMessageStringTable.getString("AgentInfo"); @@ -2797,8 +2551,8 @@ void init_prehash_data() _PREHASH_SourceID = gMessageStringTable.getString("SourceID"); _PREHASH_ChangeUserRights = gMessageStringTable.getString("ChangeUserRights"); _PREHASH_TeleportFlags = gMessageStringTable.getString("TeleportFlags"); - _PREHASH_AssetData = gMessageStringTable.getString("AssetData"); _PREHASH_SlaveParcelData = gMessageStringTable.getString("SlaveParcelData"); + _PREHASH_AssetData = gMessageStringTable.getString("AssetData"); _PREHASH_MultipleObjectUpdate = gMessageStringTable.getString("MultipleObjectUpdate"); _PREHASH_ObjectUpdate = gMessageStringTable.getString("ObjectUpdate"); _PREHASH_ImprovedTerseObjectUpdate = gMessageStringTable.getString("ImprovedTerseObjectUpdate"); @@ -2814,7 +2568,6 @@ void init_prehash_data() _PREHASH_ClaimDate = gMessageStringTable.getString("ClaimDate"); _PREHASH_MergeParcel = gMessageStringTable.getString("MergeParcel"); _PREHASH_Priority = gMessageStringTable.getString("Priority"); - _PREHASH_Building = gMessageStringTable.getString("Building"); _PREHASH_QueryText = gMessageStringTable.getString("QueryText"); _PREHASH_GroupNoticeAdd = gMessageStringTable.getString("GroupNoticeAdd"); _PREHASH_ReturnType = gMessageStringTable.getString("ReturnType"); @@ -2824,7 +2577,6 @@ void init_prehash_data() _PREHASH_RequestMultipleObjects = gMessageStringTable.getString("RequestMultipleObjects"); _PREHASH_RetrieveInstantMessages = gMessageStringTable.getString("RetrieveInstantMessages"); _PREHASH_OpenCircuit = gMessageStringTable.getString("OpenCircuit"); - _PREHASH_SecureSessionID = gMessageStringTable.getString("SecureSessionID"); _PREHASH_CrossedRegion = gMessageStringTable.getString("CrossedRegion"); _PREHASH_DirGroupsReply = gMessageStringTable.getString("DirGroupsReply"); _PREHASH_AvatarGroupsReply = gMessageStringTable.getString("AvatarGroupsReply"); @@ -2835,18 +2587,14 @@ void init_prehash_data() _PREHASH_ParentEstate = gMessageStringTable.getString("ParentEstate"); _PREHASH_EstateName = gMessageStringTable.getString("EstateName"); _PREHASH_MuteName = gMessageStringTable.getString("MuteName"); - _PREHASH_StartParcelRename = gMessageStringTable.getString("StartParcelRename"); - _PREHASH_BulkParcelRename = gMessageStringTable.getString("BulkParcelRename"); _PREHASH_ParcelRename = gMessageStringTable.getString("ParcelRename"); _PREHASH_ViewerFilename = gMessageStringTable.getString("ViewerFilename"); - _PREHASH_Positive = gMessageStringTable.getString("Positive"); _PREHASH_UserReportInternal = gMessageStringTable.getString("UserReportInternal"); _PREHASH_AvatarPropertiesRequest = gMessageStringTable.getString("AvatarPropertiesRequest"); _PREHASH_ParcelPropertiesRequest = gMessageStringTable.getString("ParcelPropertiesRequest"); _PREHASH_GroupProfileRequest = gMessageStringTable.getString("GroupProfileRequest"); _PREHASH_AgentDataUpdateRequest = gMessageStringTable.getString("AgentDataUpdateRequest"); _PREHASH_PriceObjectScaleFactor = gMessageStringTable.getString("PriceObjectScaleFactor"); - _PREHASH_DirPicksQuery = gMessageStringTable.getString("DirPicksQuery"); _PREHASH_OpenEnrollment = gMessageStringTable.getString("OpenEnrollment"); _PREHASH_GroupData = gMessageStringTable.getString("GroupData"); _PREHASH_RequestGodlikePowers = gMessageStringTable.getString("RequestGodlikePowers"); @@ -2857,7 +2605,6 @@ void init_prehash_data() _PREHASH_FirstDetachAll = gMessageStringTable.getString("FirstDetachAll"); _PREHASH_EstateID = gMessageStringTable.getString("EstateID"); _PREHASH_ImprovedInstantMessage = gMessageStringTable.getString("ImprovedInstantMessage"); - _PREHASH_AgentQuit = gMessageStringTable.getString("AgentQuit"); _PREHASH_CheckParcelSales = gMessageStringTable.getString("CheckParcelSales"); _PREHASH_ParcelSales = gMessageStringTable.getString("ParcelSales"); _PREHASH_CurrentInterval = gMessageStringTable.getString("CurrentInterval"); @@ -2874,12 +2621,8 @@ void init_prehash_data() _PREHASH_SystemKickUser = gMessageStringTable.getString("SystemKickUser"); _PREHASH_TransactionTime = gMessageStringTable.getString("TransactionTime"); _PREHASH_TimeToLive = gMessageStringTable.getString("TimeToLive"); - _PREHASH_StartParcelRemove = gMessageStringTable.getString("StartParcelRemove"); - _PREHASH_BulkParcelRemove = gMessageStringTable.getString("BulkParcelRemove"); _PREHASH_OldAgentID = gMessageStringTable.getString("OldAgentID"); - _PREHASH_BonusEstimate = gMessageStringTable.getString("BonusEstimate"); _PREHASH_MusicURL = gMessageStringTable.getString("MusicURL"); - _PREHASH_CompleteLure = gMessageStringTable.getString("CompleteLure"); _PREHASH_ParcelPrimBonus = gMessageStringTable.getString("ParcelPrimBonus"); _PREHASH_EjectUser = gMessageStringTable.getString("EjectUser"); _PREHASH_CoarseLocationUpdate = gMessageStringTable.getString("CoarseLocationUpdate"); @@ -2912,10 +2655,6 @@ void init_prehash_data() _PREHASH_EstateOwnerID = gMessageStringTable.getString("EstateOwnerID"); _PREHASH_LogoutRequest = gMessageStringTable.getString("LogoutRequest"); _PREHASH_AssetUploadRequest = gMessageStringTable.getString("AssetUploadRequest"); - _PREHASH_ReputationIndividualRequest = gMessageStringTable.getString("ReputationIndividualRequest"); - _PREHASH_MajorVersion = gMessageStringTable.getString("MajorVersion"); - _PREHASH_MinorVersion = gMessageStringTable.getString("MinorVersion"); - _PREHASH_SimulatorAssign = gMessageStringTable.getString("SimulatorAssign"); _PREHASH_TransactionType = gMessageStringTable.getString("TransactionType"); _PREHASH_AvatarPropertiesUpdate = gMessageStringTable.getString("AvatarPropertiesUpdate"); _PREHASH_ParcelPropertiesUpdate = gMessageStringTable.getString("ParcelPropertiesUpdate"); @@ -2924,7 +2663,6 @@ void init_prehash_data() _PREHASH_DeRezAck = gMessageStringTable.getString("DeRezAck"); _PREHASH_TakeControls = gMessageStringTable.getString("TakeControls"); _PREHASH_DirLandReply = gMessageStringTable.getString("DirLandReply"); - _PREHASH_SpaceLocationTeleportReply = gMessageStringTable.getString("SpaceLocationTeleportReply"); _PREHASH_MuteType = gMessageStringTable.getString("MuteType"); _PREHASH_IMViaEMail = gMessageStringTable.getString("IMViaEMail"); _PREHASH_RentPrice = gMessageStringTable.getString("RentPrice"); diff --git a/indra/llmessage/message_prehash.h b/indra/llmessage/message_prehash.h index 209b399ce8..71661ef83d 100644 --- a/indra/llmessage/message_prehash.h +++ b/indra/llmessage/message_prehash.h @@ -10,7 +10,7 @@ #define LL_MESSAGE_PREHASH_H /** - * Generated from message template version number 1.053 + * Generated from message template version number 2.000 */ @@ -39,7 +39,6 @@ extern char * _PREHASH_ScriptAnswerYes; extern char * _PREHASH_PartnerID; extern char * _PREHASH_DirLandQuery; extern char * _PREHASH_TeleportStart; -extern char * _PREHASH_LogMessages; extern char * _PREHASH_AboutText; extern char * _PREHASH_VisualParam; extern char * _PREHASH_GroupPrims; @@ -47,10 +46,8 @@ extern char * _PREHASH_SelectedPrims; extern char * _PREHASH_ID; extern char * _PREHASH_UUIDNameRequest; extern char * _PREHASH_UUIDGroupNameRequest; -extern char * _PREHASH_MoneyTransactionsRequest; extern char * _PREHASH_GroupAccountTransactionsRequest; extern char * _PREHASH_MapNameRequest; -extern char * _PREHASH_MailTaskSimRequest; extern char * _PREHASH_UpdateSimulator; extern char * _PREHASH_BillableFactor; extern char * _PREHASH_ObjectBonusFactor; @@ -60,7 +57,6 @@ extern char * _PREHASH_ConfirmEnableSimulator; extern char * _PREHASH_LayerType; extern char * _PREHASH_OwnerRole; extern char * _PREHASH_ParcelOverlay; -extern char * _PREHASH_AdjustBalance; extern char * _PREHASH_GroupOwned; extern char * _PREHASH_IP; extern char * _PREHASH_ChatFromViewer; @@ -95,8 +91,8 @@ extern char * _PREHASH_SensedData; extern char * _PREHASH_UpdateBlock; extern char * _PREHASH_ClassifiedGodDelete; extern char * _PREHASH_ObjectGrabUpdate; -extern char * _PREHASH_TaxDate; extern char * _PREHASH_LocationPos; +extern char * _PREHASH_TaxDate; extern char * _PREHASH_StartDateTime; extern char * _PREHASH_ObjectUpdateCached; extern char * _PREHASH_Packets; @@ -128,14 +124,11 @@ extern char * _PREHASH_AABBMin; extern char * _PREHASH_ClassifiedFlags; extern char * _PREHASH_ControlFlags; extern char * _PREHASH_TeleportRequest; -extern char * _PREHASH_SpaceLocationTeleportRequest; -extern char * _PREHASH_LeaderBoardRequest; extern char * _PREHASH_ScriptTeleportRequest; +extern char * _PREHASH_EstateCovenantRequest; extern char * _PREHASH_DateUTC; extern char * _PREHASH_TaskIDs; -extern char * _PREHASH_EstateCovenantRequest; extern char * _PREHASH_RequestResult; -extern char * _PREHASH_ReputationAgentAssign; extern char * _PREHASH_CanAcceptAgents; extern char * _PREHASH_ObjectSaleInfo; extern char * _PREHASH_KillChildAgents; @@ -147,7 +140,6 @@ extern char * _PREHASH_InfoBlock; extern char * _PREHASH_OwnershipCost; extern char * _PREHASH_AvatarNotesUpdate; extern char * _PREHASH_PID; -extern char * _PREHASH_TimeString; extern char * _PREHASH_DirPopularReply; extern char * _PREHASH_TerrainHeightRange00; extern char * _PREHASH_SimData; @@ -173,7 +165,6 @@ extern char * _PREHASH_Objects; extern char * _PREHASH_URL; extern char * _PREHASH_CreationDate; extern char * _PREHASH_JointPivot; -extern char * _PREHASH_RateeID; extern char * _PREHASH_FPS; extern char * _PREHASH_HasTelehub; extern char * _PREHASH_PathEnd; @@ -198,7 +189,6 @@ extern char * _PREHASH_GroupNoticesListReply; extern char * _PREHASH_ParcelAccessListReply; extern char * _PREHASH_RpcChannelReply; extern char * _PREHASH_RegionPresenceResponse; -extern char * _PREHASH_AgentPresenceResponse; extern char * _PREHASH_CharterMember; extern char * _PREHASH_EdgeData; extern char * _PREHASH_NameData; @@ -212,14 +202,12 @@ extern char * _PREHASH_Mag; extern char * _PREHASH_ParcelPropertiesRequestByID; extern char * _PREHASH_ObjectLink; extern char * _PREHASH_RpcScriptReplyInbound; -extern char * _PREHASH_BoardData; extern char * _PREHASH_RezData; extern char * _PREHASH_RemoveInventoryObjects; extern char * _PREHASH_GroupProposalBallot; extern char * _PREHASH_RPCServerIP; extern char * _PREHASH_Far; extern char * _PREHASH_GodSessionID; -extern char * _PREHASH_ViewerDigest; extern char * _PREHASH_FLAboutText; extern char * _PREHASH_RegionHandshakeReply; extern char * _PREHASH_GroupActiveProposalItemReply; @@ -231,7 +219,6 @@ extern char * _PREHASH_Set; extern char * _PREHASH_NewName; extern char * _PREHASH_Key; extern char * _PREHASH_AgentID; -extern char * _PREHASH_OnlineStatusRequest; extern char * _PREHASH_EventNotificationRemoveRequest; extern char * _PREHASH_NewFolderID; extern char * _PREHASH_Arc; @@ -243,7 +230,6 @@ extern char * _PREHASH_Top; extern char * _PREHASH_MiscStats; extern char * _PREHASH_ImageID; extern char * _PREHASH_DataPacket; -extern char * _PREHASH_ObjectDehinge; extern char * _PREHASH_You; extern char * _PREHASH_ScriptControlChange; extern char * _PREHASH_LoadURL; @@ -260,9 +246,9 @@ extern char * _PREHASH_Contribution; extern char * _PREHASH_SetGroupContribution; extern char * _PREHASH_Offline; extern char * _PREHASH_AgentIsNowWearing; -extern char * _PREHASH_SecPerDay; extern char * _PREHASH_Members; extern char * _PREHASH_FailedResends; +extern char * _PREHASH_SecPerDay; extern char * _PREHASH_CameraCenter; extern char * _PREHASH_CameraLeftAxis; extern char * _PREHASH_ExBlock; @@ -270,7 +256,6 @@ extern char * _PREHASH_Channel; extern char * _PREHASH_NetTest; extern char * _PREHASH_DiscardLevel; extern char * _PREHASH_LayerID; -extern char * _PREHASH_RatorID; extern char * _PREHASH_GrabOffset; extern char * _PREHASH_SimPort; extern char * _PREHASH_PricePerMeter; @@ -290,21 +275,16 @@ extern char * _PREHASH_SitName; extern char * _PREHASH_RegionsVisited; extern char * _PREHASH_DirClassifiedReply; extern char * _PREHASH_AvatarClassifiedReply; -extern char * _PREHASH_ReputationIndividualReply; extern char * _PREHASH_MediaURL; extern char * _PREHASH_CompleteAgentMovement; -extern char * _PREHASH_SpaceIP; extern char * _PREHASH_ClassifiedID; extern char * _PREHASH_LocalID; +extern char * _PREHASH_SpaceIP; extern char * _PREHASH_RemoveItem; extern char * _PREHASH_LogFailedMoneyTransaction; extern char * _PREHASH_ViewerStartAuction; extern char * _PREHASH_StartAuction; -extern char * _PREHASH_NameValueName; -extern char * _PREHASH_AngVelX; extern char * _PREHASH_DuplicateFlags; -extern char * _PREHASH_AngVelY; -extern char * _PREHASH_AngVelZ; extern char * _PREHASH_TextColor; extern char * _PREHASH_SlaveID; extern char * _PREHASH_Charter; @@ -315,21 +295,16 @@ extern char * _PREHASH_ParcelAuctions; extern char * _PREHASH_OwnerIsGroup; extern char * _PREHASH_NameValuePair; extern char * _PREHASH_RemoveNameValuePair; -extern char * _PREHASH_GetNameValuePair; extern char * _PREHASH_BulkUpdateInventory; extern char * _PREHASH_UpdateTaskInventory; extern char * _PREHASH_RemoveTaskInventory; extern char * _PREHASH_MoveTaskInventory; extern char * _PREHASH_RequestTaskInventory; extern char * _PREHASH_ReplyTaskInventory; -extern char * _PREHASH_DeclineInventory; extern char * _PREHASH_AggregatePermInventory; -extern char * _PREHASH_SimulatorInfo; -extern char * _PREHASH_MoneyTransactionsReply; extern char * _PREHASH_GroupAccountTransactionsReply; -extern char * _PREHASH_MailTaskSimReply; +extern char * _PREHASH_SimulatorInfo; extern char * _PREHASH_WearableData; -extern char * _PREHASH_StatisticsData; extern char * _PREHASH_Enabled; extern char * _PREHASH_Savings; extern char * _PREHASH_SimulatorLoad; @@ -341,15 +316,12 @@ extern char * _PREHASH_JoinGroupRequest; extern char * _PREHASH_LeaveGroupRequest; extern char * _PREHASH_InviteGroupRequest; extern char * _PREHASH_LiveHelpGroupRequest; -extern char * _PREHASH_ServerVersion; extern char * _PREHASH_PriceParcelClaimFactor; extern char * _PREHASH_BillableArea; extern char * _PREHASH_ObjectID; extern char * _PREHASH_ObjectFlagUpdate; extern char * _PREHASH_GroupRoleUpdate; extern char * _PREHASH_RequestInventoryAsset; -extern char * _PREHASH_RedoLand; -extern char * _PREHASH_TravelAccess; extern char * _PREHASH_ChangedGrid; extern char * _PREHASH_AgentDropGroup; extern char * _PREHASH_Details; @@ -382,7 +354,6 @@ extern char * _PREHASH_Timestamp; extern char * _PREHASH_GlobalPos; extern char * _PREHASH_GrabOffsetInitial; extern char * _PREHASH_IsTrial; -extern char * _PREHASH_FinalizeLogout; extern char * _PREHASH_ObjectDuplicateOnRay; extern char * _PREHASH_GroupMembershipCount; extern char * _PREHASH_MethodData; @@ -418,32 +389,26 @@ extern char * _PREHASH_TaskData; extern char * _PREHASH_SimWideMaxPrims; extern char * _PREHASH_TotalPrims; extern char * _PREHASH_ProfileBegin; -extern char * _PREHASH_MoneyDetailsRequest; extern char * _PREHASH_Request; extern char * _PREHASH_GroupAccountDetailsRequest; extern char * _PREHASH_GroupActiveProposalsRequest; extern char * _PREHASH_StringValue; -extern char * _PREHASH_ClosestSimulator; extern char * _PREHASH_Version; extern char * _PREHASH_OtherCount; extern char * _PREHASH_MemberCount; extern char * _PREHASH_ChatData; extern char * _PREHASH_IsGroupOwned; extern char * _PREHASH_EnergyEfficiency; -extern char * _PREHASH_MaxPlace; extern char * _PREHASH_PickInfoUpdate; extern char * _PREHASH_PickDelete; extern char * _PREHASH_ScriptReset; extern char * _PREHASH_Requester; extern char * _PREHASH_ForSale; extern char * _PREHASH_NearestLandingRegionReply; -extern char * _PREHASH_RecordAgentPresence; -extern char * _PREHASH_EraseAgentPresence; extern char * _PREHASH_ParcelID; extern char * _PREHASH_Godlike; extern char * _PREHASH_TotalDebits; extern char * _PREHASH_Direction; -extern char * _PREHASH_Appearance; extern char * _PREHASH_HealthData; extern char * _PREHASH_LeftAxis; extern char * _PREHASH_LocationBlock; @@ -451,41 +416,31 @@ extern char * _PREHASH_ObjectImage; extern char * _PREHASH_TerrainStartHeight00; extern char * _PREHASH_TerrainStartHeight01; extern char * _PREHASH_TerrainStartHeight10; -extern char * _PREHASH_ObjectHinge; extern char * _PREHASH_TerrainStartHeight11; -extern char * _PREHASH_MetersPerGrid; extern char * _PREHASH_WaterHeight; extern char * _PREHASH_FetchInventoryReply; -extern char * _PREHASH_MoneySummaryReply; extern char * _PREHASH_GroupAccountSummaryReply; extern char * _PREHASH_AttachedSound; extern char * _PREHASH_ParamInUse; extern char * _PREHASH_GodKickUser; extern char * _PREHASH_PickName; extern char * _PREHASH_TaskName; -extern char * _PREHASH_SubType; extern char * _PREHASH_ObjectCount; extern char * _PREHASH_RegionPresenceRequestByHandle; extern char * _PREHASH_RezSingleAttachmentFromInv; extern char * _PREHASH_ChildAgentUpdate; -extern char * _PREHASH_ToID; -extern char * _PREHASH_ViewerPort; extern char * _PREHASH_IsOwnerGroup; extern char * _PREHASH_AgentHeightWidth; extern char * _PREHASH_VerticalAngle; extern char * _PREHASH_WearableType; extern char * _PREHASH_AggregatePermNextOwner; extern char * _PREHASH_ShowInList; -extern char * _PREHASH_PositionSuggestion; extern char * _PREHASH_UpdateParcel; -extern char * _PREHASH_ClearAgentSessions; extern char * _PREHASH_SetAlwaysRun; extern char * _PREHASH_NVPair; extern char * _PREHASH_SearchType; extern char * _PREHASH_ObjectSpinStart; extern char * _PREHASH_UseEstateSun; -extern char * _PREHASH_LogoutBlock; -extern char * _PREHASH_RelayLogControl; extern char * _PREHASH_RegionID; extern char * _PREHASH_AbuseRegionID; extern char * _PREHASH_Creator; @@ -494,14 +449,12 @@ extern char * _PREHASH_DirEventsReply; extern char * _PREHASH_EventInfoReply; extern char * _PREHASH_UserInfoReply; extern char * _PREHASH_PathRadiusOffset; -extern char * _PREHASH_SessionInfo; extern char * _PREHASH_TextureData; extern char * _PREHASH_ChatPass; extern char * _PREHASH_TargetID; extern char * _PREHASH_DefaultPayPrice; extern char * _PREHASH_UserLocation; extern char * _PREHASH_MaxPrims; -extern char * _PREHASH_RegionIP; extern char * _PREHASH_LandmarkID; extern char * _PREHASH_InitiateDownload; extern char * _PREHASH_Name; @@ -509,18 +462,13 @@ extern char * _PREHASH_OtherCleanTime; extern char * _PREHASH_ParcelSetOtherCleanTime; extern char * _PREHASH_TeleportPriceExponent; extern char * _PREHASH_Gain; -extern char * _PREHASH_VelX; extern char * _PREHASH_PacketAck; extern char * _PREHASH_PathSkew; -extern char * _PREHASH_Negative; -extern char * _PREHASH_VelY; extern char * _PREHASH_SimulatorShutdownRequest; extern char * _PREHASH_NearestLandingRegionRequest; -extern char * _PREHASH_VelZ; extern char * _PREHASH_OtherID; extern char * _PREHASH_MemberID; extern char * _PREHASH_MapLayerRequest; -extern char * _PREHASH_PatchVersion; extern char * _PREHASH_ObjectScale; extern char * _PREHASH_TargetIP; extern char * _PREHASH_Redo; @@ -563,27 +511,20 @@ extern char * _PREHASH_Perp; extern char * _PREHASH_Code; extern char * _PREHASH_InvType; extern char * _PREHASH_AgentFOV; -extern char * _PREHASH_BulkMoneyTransfer; extern char * _PREHASH_Audible; extern char * _PREHASH_AuctionData; extern char * _PREHASH_IDBlock; -extern char * _PREHASH_ReputationData; extern char * _PREHASH_West; extern char * _PREHASH_Undo; extern char * _PREHASH_TotalNumItems; extern char * _PREHASH_Info; extern char * _PREHASH_Area; -extern char * _PREHASH_Behavior; extern char * _PREHASH_SimCrashed; extern char * _PREHASH_Text; -extern char * _PREHASH_AgentToNewRegion; extern char * _PREHASH_PriceGroupCreate; extern char * _PREHASH_ObjectShape; extern char * _PREHASH_GroupRoleDataReply; -extern char * _PREHASH_PosX; -extern char * _PREHASH_PosY; extern char * _PREHASH_MuteCRC; -extern char * _PREHASH_PosZ; extern char * _PREHASH_Size; extern char * _PREHASH_FromAddress; extern char * _PREHASH_Body; @@ -601,16 +542,14 @@ extern char * _PREHASH_Stat; extern char * _PREHASH_SoundID; extern char * _PREHASH_Item; extern char * _PREHASH_User; -extern char * _PREHASH_RemoteInfos; extern char * _PREHASH_Prey; -extern char * _PREHASH_UsecSinceStart; extern char * _PREHASH_RayStart; +extern char * _PREHASH_UsecSinceStart; extern char * _PREHASH_ParcelData; extern char * _PREHASH_CameraUpAxis; extern char * _PREHASH_ScriptDialog; extern char * _PREHASH_MasterParcelData; extern char * _PREHASH_Invalid; -extern char * _PREHASH_MinPlace; extern char * _PREHASH_ProfileCurve; extern char * _PREHASH_ParcelAccessListUpdate; extern char * _PREHASH_MuteListUpdate; @@ -629,14 +568,12 @@ extern char * _PREHASH_DeRezObject; extern char * _PREHASH_IsTemporary; extern char * _PREHASH_InsigniaID; extern char * _PREHASH_CheckFlags; -extern char * _PREHASH_TransferPriority; extern char * _PREHASH_EventID; extern char * _PREHASH_Selected; extern char * _PREHASH_FromAgentId; extern char * _PREHASH_Type; extern char * _PREHASH_ChatType; extern char * _PREHASH_ReportData; -extern char * _PREHASH_LeaderBoardData; extern char * _PREHASH_RequestBlock; extern char * _PREHASH_GrantData; extern char * _PREHASH_DetachAttachmentIntoInv; @@ -652,12 +589,9 @@ extern char * _PREHASH_OnlineNotification; extern char * _PREHASH_OfflineNotification; extern char * _PREHASH_SendPostcard; extern char * _PREHASH_RequestFlags; -extern char * _PREHASH_MoneyHistoryRequest; -extern char * _PREHASH_MoneySummaryRequest; extern char * _PREHASH_GroupAccountSummaryRequest; extern char * _PREHASH_GroupVoteHistoryRequest; extern char * _PREHASH_ParamValue; -extern char * _PREHASH_Checksum; extern char * _PREHASH_MaxAgents; extern char * _PREHASH_CreateNewOutfitAttachments; extern char * _PREHASH_RegionHandle; @@ -667,12 +601,10 @@ extern char * _PREHASH_AvatarInterestsUpdate; extern char * _PREHASH_GroupNoticeID; extern char * _PREHASH_ParcelName; extern char * _PREHASH_PriceObjectRent; -extern char * _PREHASH_ConnectAgentToUserserver; -extern char * _PREHASH_ConnectToUserserver; extern char * _PREHASH_OfferCallingCard; -extern char * _PREHASH_AgentAccess; extern char * _PREHASH_AcceptCallingCard; extern char * _PREHASH_DeclineCallingCard; +extern char * _PREHASH_AgentAccess; extern char * _PREHASH_DataHomeLocationReply; extern char * _PREHASH_EventLocationReply; extern char * _PREHASH_TerseDateID; @@ -690,8 +622,8 @@ extern char * _PREHASH_Invoice; extern char * _PREHASH_IntervalDays; extern char * _PREHASH_PathScaleX; extern char * _PREHASH_FromTaskID; -extern char * _PREHASH_TimeInfo; extern char * _PREHASH_PathScaleY; +extern char * _PREHASH_TimeInfo; extern char * _PREHASH_PublicCount; extern char * _PREHASH_ParcelJoin; extern char * _PREHASH_GroupRolesCount; @@ -716,7 +648,6 @@ extern char * _PREHASH_NearestLandingRegionUpdated; extern char * _PREHASH_PassToAgent; extern char * _PREHASH_PreyAgent; extern char * _PREHASH_SimStats; -extern char * _PREHASH_Options; extern char * _PREHASH_LogoutReply; extern char * _PREHASH_FeatureDisabled; extern char * _PREHASH_ObjectLocalID; @@ -727,10 +658,8 @@ extern char * _PREHASH_Destination; extern char * _PREHASH_MasterID; extern char * _PREHASH_TransferData; extern char * _PREHASH_WantToMask; -extern char * _PREHASH_AvatarData; extern char * _PREHASH_ParcelSelectObjects; extern char * _PREHASH_ExtraParams; -extern char * _PREHASH_LogLogin; extern char * _PREHASH_CreatorID; extern char * _PREHASH_Summary; extern char * _PREHASH_BuyObjectInventory; @@ -771,8 +700,8 @@ extern char * _PREHASH_ButtonLabel; extern char * _PREHASH_GranterID; extern char * _PREHASH_WantToText; extern char * _PREHASH_ReportType; -extern char * _PREHASH_DataBlock; extern char * _PREHASH_SimulatorReady; +extern char * _PREHASH_DataBlock; extern char * _PREHASH_AnimationSourceList; extern char * _PREHASH_SubscribeLoad; extern char * _PREHASH_UnsubscribeLoad; @@ -799,9 +728,8 @@ extern char * _PREHASH_Header; extern char * _PREHASH_GestureFlags; extern char * _PREHASH_XferID; extern char * _PREHASH_StatValue; -extern char * _PREHASH_PickID; extern char * _PREHASH_TaskID; -extern char * _PREHASH_GridsPerEdge; +extern char * _PREHASH_PickID; extern char * _PREHASH_RayEnd; extern char * _PREHASH_Throttles; extern char * _PREHASH_RebakeAvatarTextures; @@ -814,30 +742,24 @@ extern char * _PREHASH_Access; extern char * _PREHASH_TitleRoleID; extern char * _PREHASH_SquareMetersCredit; extern char * _PREHASH_Filename; -extern char * _PREHASH_SecuredTemplateChecksumRequest; -extern char * _PREHASH_TemplateChecksumRequest; -extern char * _PREHASH_AgentPresenceRequest; extern char * _PREHASH_ClassifiedInfoRequest; extern char * _PREHASH_ParcelInfoRequest; extern char * _PREHASH_ParcelObjectOwnersRequest; extern char * _PREHASH_TeleportLandmarkRequest; extern char * _PREHASH_EventInfoRequest; -extern char * _PREHASH_ChatFromSimulator; -extern char * _PREHASH_PickInfoRequest; extern char * _PREHASH_MoneyBalanceRequest; extern char * _PREHASH_GroupMembersRequest; extern char * _PREHASH_GroupRoleMembersRequest; +extern char * _PREHASH_ChatFromSimulator; extern char * _PREHASH_OldFolderID; extern char * _PREHASH_UserInfoRequest; extern char * _PREHASH_TextureID; extern char * _PREHASH_ProfileURL; extern char * _PREHASH_Handle; -extern char * _PREHASH_StartParcelRenameAck; extern char * _PREHASH_ButtonIndex; extern char * _PREHASH_GetScriptRunning; extern char * _PREHASH_SetScriptRunning; extern char * _PREHASH_Health; -extern char * _PREHASH_FileID; extern char * _PREHASH_CircuitInfo; extern char * _PREHASH_ObjectBuy; extern char * _PREHASH_ProfileEnd; @@ -862,7 +784,6 @@ extern char * _PREHASH_PingID; extern char * _PREHASH_Change; extern char * _PREHASH_Height; extern char * _PREHASH_Region; -extern char * _PREHASH_MoneyHistoryReply; extern char * _PREHASH_TelehubInfo; extern char * _PREHASH_StateSave; extern char * _PREHASH_RoleData; @@ -873,11 +794,10 @@ extern char * _PREHASH_ParcelGodMarkAsContent; extern char * _PREHASH_UsePhysics; extern char * _PREHASH_RegionDenyTransacted; extern char * _PREHASH_JointType; -extern char * _PREHASH_TaxEstimate; extern char * _PREHASH_ObjectTaxEstimate; extern char * _PREHASH_LightTaxEstimate; -extern char * _PREHASH_TeleportLandingStatusChanged; extern char * _PREHASH_LandTaxEstimate; +extern char * _PREHASH_TeleportLandingStatusChanged; extern char * _PREHASH_GroupTaxEstimate; extern char * _PREHASH_AvgViewerFPS; extern char * _PREHASH_Buttons; @@ -909,8 +829,6 @@ extern char * _PREHASH_WinnerID; extern char * _PREHASH_ChannelType; extern char * _PREHASH_NonExemptMembers; extern char * _PREHASH_Agents; -extern char * _PREHASH_SimulatorStart; -extern char * _PREHASH_Enable; extern char * _PREHASH_MemberData; extern char * _PREHASH_ToGroupID; extern char * _PREHASH_ImageNotInDatabase; @@ -918,27 +836,21 @@ extern char * _PREHASH_StartDate; extern char * _PREHASH_AnimID; extern char * _PREHASH_Serial; extern char * _PREHASH_AbuseRegionName; -extern char * _PREHASH_ControlPort; extern char * _PREHASH_ModifyLand; extern char * _PREHASH_Digest; extern char * _PREHASH_Victim; extern char * _PREHASH_Script; -extern char * _PREHASH_TemplateChecksumReply; extern char * _PREHASH_PickInfoReply; extern char * _PREHASH_MoneyBalanceReply; extern char * _PREHASH_RoutedMoneyBalanceReply; extern char * _PREHASH_RoleID; extern char * _PREHASH_RegionInfo; -extern char * _PREHASH_Sequence; extern char * _PREHASH_GodUpdateRegionInfo; -extern char * _PREHASH_LocalX; -extern char * _PREHASH_LocalY; extern char * _PREHASH_StartAnim; -extern char * _PREHASH_Location; extern char * _PREHASH_Action; +extern char * _PREHASH_Location; extern char * _PREHASH_Rights; extern char * _PREHASH_SearchDir; -extern char * _PREHASH_Active; extern char * _PREHASH_TransferRequest; extern char * _PREHASH_ScriptSensorRequest; extern char * _PREHASH_MoneyTransferRequest; @@ -949,8 +861,6 @@ extern char * _PREHASH_Center; extern char * _PREHASH_SharedData; extern char * _PREHASH_PSBlock; extern char * _PREHASH_UUIDNameBlock; -extern char * _PREHASH_Viewer; -extern char * _PREHASH_GroupNoticeDelete; extern char * _PREHASH_GroupTitleUpdate; extern char * _PREHASH_Method; extern char * _PREHASH_TouchName; @@ -962,11 +872,9 @@ extern char * _PREHASH_GodlikeMessage; extern char * _PREHASH_SystemMessage; extern char * _PREHASH_BodyRotation; extern char * _PREHASH_SearchRegions; -extern char * _PREHASH_Ignore; extern char * _PREHASH_AnimationData; extern char * _PREHASH_StatID; extern char * _PREHASH_ItemID; -extern char * _PREHASH_AvatarStatisticsReply; extern char * _PREHASH_ScriptDialogReply; extern char * _PREHASH_RegionIDAndHandleReply; extern char * _PREHASH_CameraAtOffset; @@ -991,7 +899,6 @@ extern char * _PREHASH_OldItemID; extern char * _PREHASH_RegionPort; extern char * _PREHASH_PriceEnergyUnit; extern char * _PREHASH_Bitmap; -extern char * _PREHASH_TrackAgentSession; extern char * _PREHASH_CacheMissType; extern char * _PREHASH_VFileID; extern char * _PREHASH_GroupInsigniaID; @@ -1039,7 +946,6 @@ extern char * _PREHASH_MeanCollisionAlert; extern char * _PREHASH_CanAcceptTasks; extern char * _PREHASH_ItemData; extern char * _PREHASH_AnimationList; -extern char * _PREHASH_PassObject; extern char * _PREHASH_Reputation; extern char * _PREHASH_IntValue; extern char * _PREHASH_TargetType; @@ -1062,10 +968,8 @@ extern char * _PREHASH_ParcelBuy; extern char * _PREHASH_DirFindQueryBackend; extern char * _PREHASH_DirPlacesQueryBackend; extern char * _PREHASH_DirClassifiedQueryBackend; -extern char * _PREHASH_DirPicksQueryBackend; extern char * _PREHASH_DirLandQueryBackend; extern char * _PREHASH_DirPopularQueryBackend; -extern char * _PREHASH_LogoutDemand; extern char * _PREHASH_HistoryData; extern char * _PREHASH_SnapshotID; extern char * _PREHASH_Aspect; @@ -1073,7 +977,6 @@ extern char * _PREHASH_ParamSize; extern char * _PREHASH_VoteCast; extern char * _PREHASH_CastsShadows; extern char * _PREHASH_EveryoneMask; -extern char * _PREHASH_SetSunPhase; extern char * _PREHASH_ObjectSpinUpdate; extern char * _PREHASH_MaturePublish; extern char * _PREHASH_UseExistingAsset; @@ -1082,7 +985,6 @@ extern char * _PREHASH_ParcelLocalID; extern char * _PREHASH_TeleportCancel; extern char * _PREHASH_UnixTime; extern char * _PREHASH_QueryFlags; -extern char * _PREHASH_LastExecFroze; extern char * _PREHASH_AlwaysRun; extern char * _PREHASH_Bottom; extern char * _PREHASH_ButtonData; @@ -1101,7 +1003,6 @@ extern char * _PREHASH_NVPairs; extern char * _PREHASH_GroupNoticesListRequest; extern char * _PREHASH_ParcelAccessListRequest; extern char * _PREHASH_MuteListRequest; -extern char * _PREHASH_StartPeriod; extern char * _PREHASH_RpcChannelRequest; extern char * _PREHASH_LandStatRequest; extern char * _PREHASH_PlacesQuery; @@ -1129,34 +1030,27 @@ extern char * _PREHASH_SnapSelection; extern char * _PREHASH_SoundTrigger; extern char * _PREHASH_TerrainRaiseLimit; extern char * _PREHASH_Quorum; -extern char * _PREHASH_TokenBlock; extern char * _PREHASH_AgentBlock; extern char * _PREHASH_CommandBlock; extern char * _PREHASH_PricePublicObjectDecay; extern char * _PREHASH_SpawnPointPos; -extern char * _PREHASH_AttachedSoundCutoffRadius; extern char * _PREHASH_VolumeDetail; extern char * _PREHASH_FromAgentName; extern char * _PREHASH_Range; extern char * _PREHASH_DirectoryVisibility; extern char * _PREHASH_PublicIP; extern char * _PREHASH_TeleportFailed; -extern char * _PREHASH_OnlineStatusReply; -extern char * _PREHASH_RequestAvatarInfo; extern char * _PREHASH_PreloadSound; extern char * _PREHASH_ScreenshotID; extern char * _PREHASH_CovenantTimestamp; extern char * _PREHASH_OldestUnacked; extern char * _PREHASH_SimulatorIP; -extern char * _PREHASH_ObjectImport; extern char * _PREHASH_Value; extern char * _PREHASH_JointAxisOrAnchor; extern char * _PREHASH_Test0; extern char * _PREHASH_Test1; extern char * _PREHASH_Test2; extern char * _PREHASH_SunPhase; -extern char * _PREHASH_Place; -extern char * _PREHASH_Phase; extern char * _PREHASH_ParcelDivide; extern char * _PREHASH_PriceObjectClaim; extern char * _PREHASH_Field; @@ -1166,7 +1060,6 @@ extern char * _PREHASH_LiveHelpGroupReply; extern char * _PREHASH_Score; extern char * _PREHASH_Image; extern char * _PREHASH_ObjectClickAction; -extern char * _PREHASH_Delta; extern char * _PREHASH_Parameter; extern char * _PREHASH_Flags; extern char * _PREHASH_Plane; @@ -1176,26 +1069,24 @@ extern char * _PREHASH_DirFindQuery; extern char * _PREHASH_Textures; extern char * _PREHASH_EventData; extern char * _PREHASH_Final; +extern char * _PREHASH_System; extern char * _PREHASH_TelehubPos; extern char * _PREHASH_ReportAutosaveCrash; extern char * _PREHASH_CreateTrustedCircuit; extern char * _PREHASH_DenyTrustedCircuit; extern char * _PREHASH_RequestTrustedCircuit; extern char * _PREHASH_Codec; -extern char * _PREHASH_Level; extern char * _PREHASH_Modal; extern char * _PREHASH_ChildAgentUnknown; extern char * _PREHASH_LandingType; extern char * _PREHASH_ScriptRunningReply; -extern char * _PREHASH_MoneyDetailsReply; extern char * _PREHASH_Reply; +extern char * _PREHASH_GroupAccountDetailsReply; extern char * _PREHASH_TelehubRot; -extern char * _PREHASH_RequestFriendship; extern char * _PREHASH_AcceptFriendship; -extern char * _PREHASH_GroupAccountDetailsReply; +extern char * _PREHASH_ItemType; extern char * _PREHASH_DwellInfo; extern char * _PREHASH_AgentResume; -extern char * _PREHASH_ItemType; extern char * _PREHASH_MailFilter; extern char * _PREHASH_Disconnect; extern char * _PREHASH_SimPosition; @@ -1222,7 +1113,6 @@ extern char * _PREHASH_VoteType; extern char * _PREHASH_CategoryID; extern char * _PREHASH_Token; extern char * _PREHASH_AggregatePerms; -extern char * _PREHASH_StartParcelRemoveAck; extern char * _PREHASH_ObjectSelect; extern char * _PREHASH_ForceObjectSelect; extern char * _PREHASH_Price; @@ -1251,7 +1141,6 @@ extern char * _PREHASH_Notes; extern char * _PREHASH_AvatarID; extern char * _PREHASH_FounderID; extern char * _PREHASH_EndPointID; -extern char * _PREHASH_StipendEstimate; extern char * _PREHASH_LocationLookAt; extern char * _PREHASH_Sound; extern char * _PREHASH_Cover; @@ -1271,12 +1160,12 @@ extern char * _PREHASH_ProfileHollow; extern char * _PREHASH_GroupRoleChanges; extern char * _PREHASH_Count; extern char * _PREHASH_South; -extern char * _PREHASH_Entry; extern char * _PREHASH_ObjectUpdateCompressed; extern char * _PREHASH_MuteFlags; extern char * _PREHASH_Group; extern char * _PREHASH_AgentPause; extern char * _PREHASH_LanguagesText; +extern char * _PREHASH_Error; extern char * _PREHASH_InternalScriptMail; extern char * _PREHASH_FindAgent; extern char * _PREHASH_AgentData; @@ -1285,7 +1174,6 @@ extern char * _PREHASH_AssetBlock; extern char * _PREHASH_AcceptNotices; extern char * _PREHASH_SetGroupAcceptNotices; extern char * _PREHASH_CloseCircuit; -extern char * _PREHASH_LogControl; extern char * _PREHASH_TeleportFinish; extern char * _PREHASH_PathRevolutions; extern char * _PREHASH_ClassifiedInfoReply; @@ -1302,7 +1190,6 @@ extern char * _PREHASH_DataHomeLocationRequest; extern char * _PREHASH_EventNotificationAddRequest; extern char * _PREHASH_ParcelDwellRequest; extern char * _PREHASH_EventLocationRequest; -extern char * _PREHASH_EndPeriod; extern char * _PREHASH_SetStartLocationRequest; extern char * _PREHASH_QueryStart; extern char * _PREHASH_EjectData; @@ -1315,7 +1202,6 @@ extern char * _PREHASH_ParcelRelease; extern char * _PREHASH_VFileType; extern char * _PREHASH_EjectGroupMemberReply; extern char * _PREHASH_ImageData; -extern char * _PREHASH_SpaceServerSimulatorTimeMessage; extern char * _PREHASH_SimulatorViewerTimeMessage; extern char * _PREHASH_Rotation; extern char * _PREHASH_Selection; @@ -1323,7 +1209,6 @@ extern char * _PREHASH_TransactionData; extern char * _PREHASH_OperationData; extern char * _PREHASH_ExpirationDate; extern char * _PREHASH_ParcelDeedToGroup; -extern char * _PREHASH_DirPicksReply; extern char * _PREHASH_AvatarPicksReply; extern char * _PREHASH_GroupTitlesReply; extern char * _PREHASH_AgentInfo; @@ -1334,8 +1219,8 @@ extern char * _PREHASH_PassPrice; extern char * _PREHASH_SourceID; extern char * _PREHASH_ChangeUserRights; extern char * _PREHASH_TeleportFlags; -extern char * _PREHASH_AssetData; extern char * _PREHASH_SlaveParcelData; +extern char * _PREHASH_AssetData; extern char * _PREHASH_MultipleObjectUpdate; extern char * _PREHASH_ObjectUpdate; extern char * _PREHASH_ImprovedTerseObjectUpdate; @@ -1351,7 +1236,6 @@ extern char * _PREHASH_TaskLocalID; extern char * _PREHASH_ClaimDate; extern char * _PREHASH_MergeParcel; extern char * _PREHASH_Priority; -extern char * _PREHASH_Building; extern char * _PREHASH_QueryText; extern char * _PREHASH_GroupNoticeAdd; extern char * _PREHASH_ReturnType; @@ -1361,7 +1245,6 @@ extern char * _PREHASH_HeaderData; extern char * _PREHASH_RequestMultipleObjects; extern char * _PREHASH_RetrieveInstantMessages; extern char * _PREHASH_OpenCircuit; -extern char * _PREHASH_SecureSessionID; extern char * _PREHASH_CrossedRegion; extern char * _PREHASH_DirGroupsReply; extern char * _PREHASH_AvatarGroupsReply; @@ -1372,18 +1255,14 @@ extern char * _PREHASH_Position; extern char * _PREHASH_ParentEstate; extern char * _PREHASH_EstateName; extern char * _PREHASH_MuteName; -extern char * _PREHASH_StartParcelRename; -extern char * _PREHASH_BulkParcelRename; extern char * _PREHASH_ParcelRename; extern char * _PREHASH_ViewerFilename; -extern char * _PREHASH_Positive; extern char * _PREHASH_UserReportInternal; extern char * _PREHASH_AvatarPropertiesRequest; extern char * _PREHASH_ParcelPropertiesRequest; extern char * _PREHASH_GroupProfileRequest; extern char * _PREHASH_AgentDataUpdateRequest; extern char * _PREHASH_PriceObjectScaleFactor; -extern char * _PREHASH_DirPicksQuery; extern char * _PREHASH_OpenEnrollment; extern char * _PREHASH_GroupData; extern char * _PREHASH_RequestGodlikePowers; @@ -1394,7 +1273,6 @@ extern char * _PREHASH_Controls; extern char * _PREHASH_FirstDetachAll; extern char * _PREHASH_EstateID; extern char * _PREHASH_ImprovedInstantMessage; -extern char * _PREHASH_AgentQuit; extern char * _PREHASH_CheckParcelSales; extern char * _PREHASH_ParcelSales; extern char * _PREHASH_CurrentInterval; @@ -1411,12 +1289,8 @@ extern char * _PREHASH_OwnerIDs; extern char * _PREHASH_SystemKickUser; extern char * _PREHASH_TransactionTime; extern char * _PREHASH_TimeToLive; -extern char * _PREHASH_StartParcelRemove; -extern char * _PREHASH_BulkParcelRemove; extern char * _PREHASH_OldAgentID; -extern char * _PREHASH_BonusEstimate; extern char * _PREHASH_MusicURL; -extern char * _PREHASH_CompleteLure; extern char * _PREHASH_ParcelPrimBonus; extern char * _PREHASH_EjectUser; extern char * _PREHASH_CoarseLocationUpdate; @@ -1449,10 +1323,6 @@ extern char * _PREHASH_ParcelProperties; extern char * _PREHASH_EstateOwnerID; extern char * _PREHASH_LogoutRequest; extern char * _PREHASH_AssetUploadRequest; -extern char * _PREHASH_ReputationIndividualRequest; -extern char * _PREHASH_MajorVersion; -extern char * _PREHASH_MinorVersion; -extern char * _PREHASH_SimulatorAssign; extern char * _PREHASH_TransactionType; extern char * _PREHASH_AvatarPropertiesUpdate; extern char * _PREHASH_ParcelPropertiesUpdate; @@ -1461,7 +1331,6 @@ extern char * _PREHASH_AbortXfer; extern char * _PREHASH_DeRezAck; extern char * _PREHASH_TakeControls; extern char * _PREHASH_DirLandReply; -extern char * _PREHASH_SpaceLocationTeleportReply; extern char * _PREHASH_MuteType; extern char * _PREHASH_IMViaEMail; extern char * _PREHASH_RentPrice; |