diff options
Diffstat (limited to 'indra/llmessage')
35 files changed, 4630 insertions, 2915 deletions
diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt index 1cad0f6d22..0f40a670fa 100644 --- a/indra/llmessage/CMakeLists.txt +++ b/indra/llmessage/CMakeLists.txt @@ -10,7 +10,9 @@ include(LLMath) include(LLMessage) include(LLVFS) include(LLAddBuildTest) +include(Python) include(Tut) +include(Python) include_directories (${CMAKE_CURRENT_SOURCE_DIR}) @@ -63,6 +65,7 @@ set(llmessage_SOURCE_FILES llpacketbuffer.cpp llpacketring.cpp llpartdata.cpp + llproxy.cpp llpumpio.cpp llregionpresenceverifier.cpp llsdappservices.cpp @@ -159,6 +162,7 @@ set(llmessage_HEADER_FILES llpacketring.h llpartdata.h llpumpio.h + llproxy.h llqueryflags.h llregionflags.h llregionhandle.h diff --git a/indra/llmessage/llassetstorage.cpp b/indra/llmessage/llassetstorage.cpp index 27a368df3d..31cdb1219b 100644 --- a/indra/llmessage/llassetstorage.cpp +++ b/indra/llmessage/llassetstorage.cpp @@ -398,6 +398,12 @@ BOOL LLAssetStorage::hasLocalAsset(const LLUUID &uuid, const LLAssetType::EType bool LLAssetStorage::findInStaticVFSAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type, LLGetAssetCallback callback, void *user_data) { + if (user_data) + { + // The *user_data should not be passed without a callback to clean it up. + llassert(callback != NULL) + } + BOOL exists = mStaticVFS->getExists(uuid, type); if (exists) { @@ -432,15 +438,26 @@ void LLAssetStorage::getAssetData(const LLUUID uuid, LLAssetType::EType type, LL llinfos << "ASSET_TRACE requesting " << uuid << " type " << LLAssetType::lookup(type) << llendl; + if (user_data) + { + // The *user_data should not be passed without a callback to clean it up. + llassert(callback != NULL) + } + if (mShutDown) { llinfos << "ASSET_TRACE cancelled " << uuid << " type " << LLAssetType::lookup(type) << " shutting down" << llendl; - return; // don't get the asset or do any callbacks, we are shutting down + + if (callback) + { + callback(mVFS, uuid, type, user_data, LL_ERR_ASSET_REQUEST_FAILED, LL_EXSTAT_NONE); + } + return; } - + if (uuid.isNull()) { - // Special case early out for NULL uuid + // Special case early out for NULL uuid and for shutting down if (callback) { callback(mVFS, uuid, type, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LL_EXSTAT_NULL_UUID); @@ -544,7 +561,7 @@ void LLAssetStorage::_queueDataRequest(const LLUUID& uuid, LLAssetType::EType at tpvf.setAsset(uuid, atype); tpvf.setCallback(downloadCompleteCallback, req); - llinfos << "Starting transfer for " << uuid << llendl; + //llinfos << "Starting transfer for " << uuid << llendl; LLTransferTargetChannel *ttcp = gTransferManager.getTargetChannel(mUpstreamHost, LLTCT_ASSET); ttcp->requestTransfer(spa, tpvf, 100.f + (is_priority ? 1.f : 0.f)); } diff --git a/indra/llmessage/llavatarnamecache.cpp b/indra/llmessage/llavatarnamecache.cpp index 767001b633..97f2792686 100644 --- a/indra/llmessage/llavatarnamecache.cpp +++ b/indra/llmessage/llavatarnamecache.cpp @@ -553,12 +553,10 @@ void LLAvatarNameCache::eraseUnrefreshed() if (!sLastExpireCheck || sLastExpireCheck < max_unrefreshed) { sLastExpireCheck = now; - cache_t::iterator it = sCache.begin(); - while (it != sCache.end()) + + for (cache_t::iterator it = sCache.begin(); it != sCache.end();) { - cache_t::iterator cur = it; - ++it; - const LLAvatarName& av_name = cur->second; + const LLAvatarName& av_name = it->second; if (av_name.mExpires < max_unrefreshed) { const LLUUID& agent_id = it->first; @@ -566,8 +564,12 @@ void LLAvatarNameCache::eraseUnrefreshed() << " user '" << av_name.mUsername << "' " << "expired " << now - av_name.mExpires << " secs ago" << LL_ENDL; - sCache.erase(cur); + sCache.erase(it++); } + else + { + ++it; + } } LL_INFOS("AvNameCache") << sCache.size() << " cached avatar names" << LL_ENDL; } diff --git a/indra/llmessage/llcurl.cpp b/indra/llmessage/llcurl.cpp index a485fa0160..6e063818e2 100644 --- a/indra/llmessage/llcurl.cpp +++ b/indra/llmessage/llcurl.cpp @@ -1,5 +1,5 @@ /** - * @file llcurl.h + * @file llcurl.cpp * @author Zero / Donovan * @date 2006-10-15 * @brief Implementation of wrapper around libcurl. @@ -46,9 +46,11 @@ #endif #include "llbufferstream.h" -#include "llstl.h" +#include "llproxy.h" #include "llsdserialize.h" +#include "llstl.h" #include "llthread.h" +#include "lltimer.h" ////////////////////////////////////////////////////////////////////////////// /* @@ -73,6 +75,7 @@ static const S32 MULTI_PERFORM_CALL_REPEAT = 5; static const S32 CURL_REQUEST_TIMEOUT = 30; // seconds static const S32 MAX_ACTIVE_REQUEST_COUNT = 100; +static // DEBUG // S32 gCurlEasyCount = 0; S32 gCurlMultiCount = 0; @@ -84,6 +87,29 @@ std::vector<LLMutex*> LLCurl::sSSLMutex; std::string LLCurl::sCAPath; std::string LLCurl::sCAFile; +bool LLCurl::sMultiThreaded = false; +static U32 sMainThreadID = 0; + +void check_curl_code(CURLcode code) +{ + if (code != CURLE_OK) + { + // linux appears to throw a curl error once per session for a bad initialization + // at a pretty random time (when enabling cookies). + llinfos << "curl error detected: " << curl_easy_strerror(code) << llendl; + } +} + +void check_curl_multi_code(CURLMcode code) +{ + if (code != CURLM_OK) + { + // linux appears to throw a curl error once per session for a bad initialization + // at a pretty random time (when enabling cookies). + llinfos << "curl multi error detected: " << curl_multi_strerror(code) << llendl; + } +} + //static void LLCurl::setCAPath(const std::string& path) { @@ -183,7 +209,7 @@ namespace boost void intrusive_ptr_release(LLCurl::Responder* p) { - if(p && 0 == --p->mReferenceCount) + if (p && 0 == --p->mReferenceCount) { delete p; } @@ -193,63 +219,55 @@ namespace boost ////////////////////////////////////////////////////////////////////////////// +std::set<CURL*> LLCurl::Easy::sFreeHandles; +std::set<CURL*> LLCurl::Easy::sActiveHandles; +LLMutex* LLCurl::Easy::sHandleMutex = NULL; +LLMutex* LLCurl::Easy::sMultiMutex = NULL; -class LLCurl::Easy +//static +CURL* LLCurl::Easy::allocEasyHandle() { - LOG_CLASS(Easy); - -private: - Easy(); - -public: - static Easy* getEasy(); - ~Easy(); - - CURL* getCurlHandle() const { return mCurlEasyHandle; } + CURL* ret = NULL; + LLMutexLock lock(sHandleMutex); + if (sFreeHandles.empty()) + { + ret = curl_easy_init(); + } + else + { + ret = *(sFreeHandles.begin()); + sFreeHandles.erase(ret); + curl_easy_reset(ret); + } - void setErrorBuffer(); - void setCA(); - - void setopt(CURLoption option, S32 value); - // These assume the setter does not free value! - void setopt(CURLoption option, void* value); - void setopt(CURLoption option, char* value); - // Copies the string so that it is gauranteed to stick around - void setoptString(CURLoption option, const std::string& value); - - void slist_append(const char* str); - void setHeaders(); - - U32 report(CURLcode); - void getTransferInfo(LLCurl::TransferInfo* info); + if (ret) + { + sActiveHandles.insert(ret); + } - void prepRequest(const std::string& url, const std::vector<std::string>& headers, ResponderPtr, bool post = false); - - const char* getErrorBuffer(); + return ret; +} - std::stringstream& getInput() { return mInput; } - std::stringstream& getHeaderOutput() { return mHeaderOutput; } - LLIOPipe::buffer_ptr_t& getOutput() { return mOutput; } - const LLChannelDescriptors& getChannels() { return mChannels; } - - void resetState(); +//static +void LLCurl::Easy::releaseEasyHandle(CURL* handle) +{ + if (!handle) + { + llerrs << "handle cannot be NULL!" << llendl; + } -private: - CURL* mCurlEasyHandle; - struct curl_slist* mHeaders; + LLMutexLock lock(sHandleMutex); - std::stringstream mRequest; - LLChannelDescriptors mChannels; - LLIOPipe::buffer_ptr_t mOutput; - std::stringstream mInput; - std::stringstream mHeaderOutput; - char mErrorBuffer[CURL_ERROR_SIZE]; - - // Note: char*'s not strings since we pass pointers to curl - std::vector<char*> mStrings; - - ResponderPtr mResponder; -}; + if (sActiveHandles.find(handle) != sActiveHandles.end()) + { + sActiveHandles.erase(handle); + sFreeHandles.insert(handle); + } + else + { + llerrs << "Invalid handle." << llendl; + } +} LLCurl::Easy::Easy() : mHeaders(NULL), @@ -261,25 +279,28 @@ LLCurl::Easy::Easy() LLCurl::Easy* LLCurl::Easy::getEasy() { Easy* easy = new Easy(); - easy->mCurlEasyHandle = curl_easy_init(); + easy->mCurlEasyHandle = allocEasyHandle(); + if (!easy->mCurlEasyHandle) { // this can happen if we have too many open files (fails in c-ares/ares_init.c) - llwarns << "curl_multi_init() returned NULL! Easy handles: " << gCurlEasyCount << " Multi handles: " << gCurlMultiCount << llendl; + llwarns << "allocEasyHandle() returned NULL! Easy handles: " << gCurlEasyCount << " Multi handles: " << gCurlMultiCount << llendl; delete easy; return NULL; } - // set no DMS caching as default for all easy handles. This prevents them adopting a + // set no DNS caching as default for all easy handles. This prevents them adopting a // multi handles cache if they are added to one. - curl_easy_setopt(easy->mCurlEasyHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0); + CURLcode result = curl_easy_setopt(easy->mCurlEasyHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0); + check_curl_code(result); + ++gCurlEasyCount; return easy; } LLCurl::Easy::~Easy() { - curl_easy_cleanup(mCurlEasyHandle); + releaseEasyHandle(mCurlEasyHandle); --gCurlEasyCount; curl_slist_free_all(mHeaders); for_each(mStrings.begin(), mStrings.end(), DeletePointerArray()); @@ -321,11 +342,11 @@ const char* LLCurl::Easy::getErrorBuffer() void LLCurl::Easy::setCA() { - if(!sCAPath.empty()) + if (!sCAPath.empty()) { setoptString(CURLOPT_CAPATH, sCAPath); } - if(!sCAFile.empty()) + if (!sCAFile.empty()) { setoptString(CURLOPT_CAINFO, sCAFile); } @@ -338,9 +359,9 @@ void LLCurl::Easy::setHeaders() void LLCurl::Easy::getTransferInfo(LLCurl::TransferInfo* info) { - curl_easy_getinfo(mCurlEasyHandle, CURLINFO_SIZE_DOWNLOAD, &info->mSizeDownload); - curl_easy_getinfo(mCurlEasyHandle, CURLINFO_TOTAL_TIME, &info->mTotalTime); - curl_easy_getinfo(mCurlEasyHandle, CURLINFO_SPEED_DOWNLOAD, &info->mSpeedDownload); + check_curl_code(curl_easy_getinfo(mCurlEasyHandle, CURLINFO_SIZE_DOWNLOAD, &info->mSizeDownload)); + check_curl_code(curl_easy_getinfo(mCurlEasyHandle, CURLINFO_TOTAL_TIME, &info->mTotalTime)); + check_curl_code(curl_easy_getinfo(mCurlEasyHandle, CURLINFO_SPEED_DOWNLOAD, &info->mSpeedDownload)); } U32 LLCurl::Easy::report(CURLcode code) @@ -350,13 +371,14 @@ U32 LLCurl::Easy::report(CURLcode code) if (code == CURLE_OK) { - curl_easy_getinfo(mCurlEasyHandle, CURLINFO_RESPONSE_CODE, &responseCode); + check_curl_code(curl_easy_getinfo(mCurlEasyHandle, CURLINFO_RESPONSE_CODE, &responseCode)); //*TODO: get reason from first line of mHeaderOutput } else { responseCode = 499; responseReason = strerror(code) + " : " + mErrorBuffer; + setopt(CURLOPT_FRESH_CONNECT, TRUE); } if (mResponder) @@ -372,17 +394,20 @@ U32 LLCurl::Easy::report(CURLcode code) // Note: these all assume the caller tracks the value (i.e. keeps it persistant) void LLCurl::Easy::setopt(CURLoption option, S32 value) { - curl_easy_setopt(mCurlEasyHandle, option, value); + CURLcode result = curl_easy_setopt(mCurlEasyHandle, option, value); + check_curl_code(result); } void LLCurl::Easy::setopt(CURLoption option, void* value) { - curl_easy_setopt(mCurlEasyHandle, option, value); + CURLcode result = curl_easy_setopt(mCurlEasyHandle, option, value); + check_curl_code(result); } void LLCurl::Easy::setopt(CURLoption option, char* value) { - curl_easy_setopt(mCurlEasyHandle, option, value); + CURLcode result = curl_easy_setopt(mCurlEasyHandle, option, value); + check_curl_code(result); } // Note: this copies the string so that the caller does not have to keep it around @@ -391,7 +416,8 @@ void LLCurl::Easy::setoptString(CURLoption option, const std::string& value) char* tstring = new char[value.length()+1]; strcpy(tstring, value.c_str()); mStrings.push_back(tstring); - curl_easy_setopt(mCurlEasyHandle, option, tstring); + CURLcode result = curl_easy_setopt(mCurlEasyHandle, option, tstring); + check_curl_code(result); } void LLCurl::Easy::slist_append(const char* str) @@ -437,15 +463,18 @@ size_t curlHeaderCallback(void* data, size_t size, size_t nmemb, void* user_data void LLCurl::Easy::prepRequest(const std::string& url, const std::vector<std::string>& headers, - ResponderPtr responder, bool post) + ResponderPtr responder, S32 time_out, bool post) { resetState(); if (post) setoptString(CURLOPT_ENCODING, ""); -// setopt(CURLOPT_VERBOSE, 1); // usefull for debugging + //setopt(CURLOPT_VERBOSE, 1); // useful for debugging setopt(CURLOPT_NOSIGNAL, 1); + // Set the CURL options for either Socks or HTTP proxy + LLProxy::getInstance()->applyProxySettings(this); + mOutput.reset(new LLBufferArray); setopt(CURLOPT_WRITEFUNCTION, (void*)&curlWriteCallback); setopt(CURLOPT_WRITEDATA, (void*)this); @@ -457,7 +486,7 @@ void LLCurl::Easy::prepRequest(const std::string& url, setopt(CURLOPT_HEADERDATA, (void*)this); // Allow up to five redirects - if(responder && responder->followRedir()) + if (responder && responder->followRedir()) { setopt(CURLOPT_FOLLOWLOCATION, 1); setopt(CURLOPT_MAXREDIRS, MAX_REDIRECTS); @@ -467,7 +496,10 @@ void LLCurl::Easy::prepRequest(const std::string& url, setCA(); setopt(CURLOPT_SSL_VERIFYPEER, true); - setopt(CURLOPT_TIMEOUT, CURL_REQUEST_TIMEOUT); + + //don't verify host name so urls with scrubbed host names will work (improves DNS performance) + setopt(CURLOPT_SSL_VERIFYHOST, 0); + setopt(CURLOPT_TIMEOUT, llmax(time_out, CURL_REQUEST_TIMEOUT)); setoptString(CURLOPT_URL, url); @@ -488,62 +520,53 @@ void LLCurl::Easy::prepRequest(const std::string& url, //////////////////////////////////////////////////////////////////////////// -class LLCurl::Multi +LLCurl::Multi::Multi() + : LLThread("Curl Multi"), + mQueued(0), + mErrorCount(0), + mPerformState(PERFORM_STATE_READY) { - LOG_CLASS(Multi); -public: - - Multi(); - ~Multi(); - - Easy* allocEasy(); - bool addEasy(Easy* easy); - - void removeEasy(Easy* easy); + mQuitting = false; - S32 process(); - S32 perform(); - - CURLMsg* info_read(S32* msgs_in_queue); - - S32 mQueued; - S32 mErrorCount; - -private: - void easyFree(Easy*); - - CURLM* mCurlMultiHandle; - - typedef std::set<Easy*> easy_active_list_t; - easy_active_list_t mEasyActiveList; - typedef std::map<CURL*, Easy*> easy_active_map_t; - easy_active_map_t mEasyActiveMap; - typedef std::set<Easy*> easy_free_list_t; - easy_free_list_t mEasyFreeList; -}; + mThreaded = LLCurl::sMultiThreaded && LLThread::currentID() == sMainThreadID; + if (mThreaded) + { + mSignal = new LLCondition(); + } + else + { + mSignal = NULL; + } -LLCurl::Multi::Multi() - : mQueued(0), - mErrorCount(0) -{ mCurlMultiHandle = curl_multi_init(); if (!mCurlMultiHandle) { llwarns << "curl_multi_init() returned NULL! Easy handles: " << gCurlEasyCount << " Multi handles: " << gCurlMultiCount << llendl; mCurlMultiHandle = curl_multi_init(); } + llassert_always(mCurlMultiHandle); ++gCurlMultiCount; } LLCurl::Multi::~Multi() { + llassert(isStopped()); + + if (LLCurl::sMultiThreaded) + { + LLCurl::Easy::sMultiMutex->lock(); + } + + delete mSignal; + mSignal = NULL; + // Clean up active for(easy_active_list_t::iterator iter = mEasyActiveList.begin(); iter != mEasyActiveList.end(); ++iter) { Easy* easy = *iter; - curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle()); + check_curl_multi_code(curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle())); delete easy; } mEasyActiveList.clear(); @@ -553,8 +576,13 @@ LLCurl::Multi::~Multi() for_each(mEasyFreeList.begin(), mEasyFreeList.end(), DeletePointer()); mEasyFreeList.clear(); - curl_multi_cleanup(mCurlMultiHandle); + check_curl_multi_code(curl_multi_cleanup(mCurlMultiHandle)); --gCurlMultiCount; + + if (LLCurl::sMultiThreaded) + { + LLCurl::Easy::sMultiMutex->unlock(); + } } CURLMsg* LLCurl::Multi::info_read(S32* msgs_in_queue) @@ -563,28 +591,65 @@ CURLMsg* LLCurl::Multi::info_read(S32* msgs_in_queue) return curlmsg; } +void LLCurl::Multi::perform() +{ + if (mThreaded) + { + if (mPerformState == PERFORM_STATE_READY) + { + mSignal->signal(); + } + } + else + { + doPerform(); + } +} + +void LLCurl::Multi::run() +{ + llassert(mThreaded); -S32 LLCurl::Multi::perform() + while (!mQuitting) + { + mSignal->wait(); + mPerformState = PERFORM_STATE_PERFORMING; + if (!mQuitting) + { + LLMutexLock lock(LLCurl::Easy::sMultiMutex); + doPerform(); + } + } +} + +void LLCurl::Multi::doPerform() { S32 q = 0; for (S32 call_count = 0; - call_count < MULTI_PERFORM_CALL_REPEAT; - call_count += 1) + call_count < MULTI_PERFORM_CALL_REPEAT; + call_count += 1) { CURLMcode code = curl_multi_perform(mCurlMultiHandle, &q); if (CURLM_CALL_MULTI_PERFORM != code || q == 0) { + check_curl_multi_code(code); break; } + } mQueued = q; - return q; + mPerformState = PERFORM_STATE_COMPLETED; } S32 LLCurl::Multi::process() { perform(); - + + if (mPerformState != PERFORM_STATE_COMPLETED) + { + return 0; + } + CURLMsg* msg; int msgs_in_queue; @@ -615,6 +680,8 @@ S32 LLCurl::Multi::process() } } } + + mPerformState = PERFORM_STATE_READY; return processed; } @@ -642,11 +709,12 @@ LLCurl::Easy* LLCurl::Multi::allocEasy() bool LLCurl::Multi::addEasy(Easy* easy) { CURLMcode mcode = curl_multi_add_handle(mCurlMultiHandle, easy->getCurlHandle()); - if (mcode != CURLM_OK) - { - llwarns << "Curl Error: " << curl_multi_strerror(mcode) << llendl; - return false; - } + check_curl_multi_code(mcode); + //if (mcode != CURLM_OK) + //{ + // llwarns << "Curl Error: " << curl_multi_strerror(mcode) << llendl; + // return false; + //} return true; } @@ -667,22 +735,14 @@ void LLCurl::Multi::easyFree(Easy* easy) void LLCurl::Multi::removeEasy(Easy* easy) { - curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle()); + check_curl_multi_code(curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle())); easyFree(easy); } //static std::string LLCurl::strerror(CURLcode errorcode) { -#if LL_DARWIN - // curl_easy_strerror was added in libcurl 7.12.0. Unfortunately, the version in the Mac OS X 10.3.9 SDK is 7.10.2... - // There's a problem with the custom curl headers in our build that keeps me from #ifdefing this on the libcurl version number - // (the correct check would be #if LIBCURL_VERSION_NUM >= 0x070c00). We'll fix the header problem soon, but for now - // just punt and print the numeric error code on the Mac. - return llformat("%d", errorcode); -#else // LL_DARWIN return std::string(curl_easy_strerror(errorcode)); -#endif // LL_DARWIN } //////////////////////////////////////////////////////////////////////////// @@ -694,11 +754,27 @@ LLCurlRequest::LLCurlRequest() : mActiveRequestCount(0) { mThreadID = LLThread::currentID(); + mProcessing = FALSE; } LLCurlRequest::~LLCurlRequest() { llassert_always(mThreadID == LLThread::currentID()); + + //stop all Multi handle background threads + for (curlmulti_set_t::iterator iter = mMultiSet.begin(); iter != mMultiSet.end(); ++iter) + { + LLCurl::Multi* multi = *iter; + multi->mQuitting = true; + if (multi->mThreaded) + { + while (!multi->isStopped()) + { + multi->mSignal->signal(); + apr_sleep(1000); + } + } + } for_each(mMultiSet.begin(), mMultiSet.end(), DeletePointer()); } @@ -706,6 +782,10 @@ void LLCurlRequest::addMulti() { llassert_always(mThreadID == LLThread::currentID()); LLCurl::Multi* multi = new LLCurl::Multi(); + if (multi->mThreaded) + { + multi->start(); + } mMultiSet.insert(multi); mActiveMulti = multi; mActiveRequestCount = 0; @@ -728,6 +808,11 @@ LLCurl::Easy* LLCurlRequest::allocEasy() bool LLCurlRequest::addEasy(LLCurl::Easy* easy) { llassert_always(mActiveMulti); + + if (mProcessing) + { + llerrs << "Posting to a LLCurlRequest instance from within a responder is not allowed (causes DNS timeouts)." << llendl; + } bool res = mActiveMulti->addEasy(easy); return res; } @@ -762,14 +847,14 @@ bool LLCurlRequest::getByteRange(const std::string& url, bool LLCurlRequest::post(const std::string& url, const headers_t& headers, const LLSD& data, - LLCurl::ResponderPtr responder) + LLCurl::ResponderPtr responder, S32 time_out) { LLCurl::Easy* easy = allocEasy(); if (!easy) { return false; } - easy->prepRequest(url, headers, responder); + easy->prepRequest(url, headers, responder, time_out); LLSDSerialize::toXML(data, easy->getInput()); S32 bytes = easy->getInput().str().length(); @@ -785,12 +870,41 @@ bool LLCurlRequest::post(const std::string& url, bool res = addEasy(easy); return res; } + +bool LLCurlRequest::post(const std::string& url, + const headers_t& headers, + const std::string& data, + LLCurl::ResponderPtr responder, S32 time_out) +{ + LLCurl::Easy* easy = allocEasy(); + if (!easy) + { + return false; + } + easy->prepRequest(url, headers, responder, time_out); + + easy->getInput().write(data.data(), data.size()); + S32 bytes = easy->getInput().str().length(); + easy->setopt(CURLOPT_POST, 1); + easy->setopt(CURLOPT_POSTFIELDS, (void*)NULL); + easy->setopt(CURLOPT_POSTFIELDSIZE, bytes); + + easy->slist_append("Content-Type: application/octet-stream"); + easy->setHeaders(); + + lldebugs << "POSTING: " << bytes << " bytes." << llendl; + bool res = addEasy(easy); + return res; +} + // Note: call once per frame S32 LLCurlRequest::process() { llassert_always(mThreadID == LLThread::currentID()); S32 res = 0; + + mProcessing = TRUE; for (curlmulti_set_t::iterator iter = mMultiSet.begin(); iter != mMultiSet.end(); ) { @@ -801,9 +915,20 @@ S32 LLCurlRequest::process() if (multi != mActiveMulti && tres == 0 && multi->mQueued == 0) { mMultiSet.erase(curiter); + multi->mQuitting = true; + if (multi->mThreaded) + { + while (!multi->isStopped()) + { + multi->mSignal->signal(); + apr_sleep(1000); + } + } + delete multi; } } + mProcessing = FALSE; return res; } @@ -817,6 +942,10 @@ S32 LLCurlRequest::getQueued() curlmulti_set_t::iterator curiter = iter++; LLCurl::Multi* multi = *curiter; queued += multi->mQueued; + if (multi->mPerformState != LLCurl::Multi::PERFORM_STATE_READY) + { + ++queued; + } } return queued; } @@ -830,16 +959,31 @@ LLCurlEasyRequest::LLCurlEasyRequest() mResultReturned(false) { mMulti = new LLCurl::Multi(); + if (mMulti->mThreaded) + { + mMulti->start(); + } mEasy = mMulti->allocEasy(); if (mEasy) { mEasy->setErrorBuffer(); mEasy->setCA(); + // Set proxy settings if configured to do so. + LLProxy::getInstance()->applyProxySettings(mEasy); } } LLCurlEasyRequest::~LLCurlEasyRequest() { + mMulti->mQuitting = true; + if (mMulti->mThreaded) + { + while (!mMulti->isStopped()) + { + mMulti->mSignal->signal(); + apr_sleep(1000); + } + } delete mMulti; } @@ -936,14 +1080,20 @@ void LLCurlEasyRequest::requestComplete() } } -S32 LLCurlEasyRequest::perform() +void LLCurlEasyRequest::perform() { - return mMulti->perform(); + mMulti->perform(); } // Usage: Call getRestult until it returns false (no more messages) bool LLCurlEasyRequest::getResult(CURLcode* result, LLCurl::TransferInfo* info) { + if (mMulti->mPerformState != LLCurl::Multi::PERFORM_STATE_COMPLETED) + { //we're busy, try again later + return false; + } + mMulti->mPerformState = LLCurl::Multi::PERFORM_STATE_READY; + if (!mEasy) { // Special case - we failed to initialize a curl_easy (can happen if too many open files) @@ -1028,13 +1178,20 @@ unsigned long LLCurl::ssl_thread_id(void) } #endif -void LLCurl::initClass() +void LLCurl::initClass(bool multi_threaded) { + sMainThreadID = LLThread::currentID(); + sMultiThreaded = multi_threaded; // Do not change this "unless you are familiar with and mean to control // internal operations of libcurl" // - http://curl.haxx.se/libcurl/c/curl_global_init.html - curl_global_init(CURL_GLOBAL_ALL); + CURLcode code = curl_global_init(CURL_GLOBAL_ALL); + + check_curl_code(code); + Easy::sHandleMutex = new LLMutex(); + Easy::sMultiMutex = new LLMutex(); + #if SAFE_SSL S32 mutex_count = CRYPTO_num_locks(); for (S32 i=0; i<mutex_count; i++) @@ -1052,7 +1209,31 @@ void LLCurl::cleanupClass() CRYPTO_set_locking_callback(NULL); for_each(sSSLMutex.begin(), sSSLMutex.end(), DeletePointer()); #endif - curl_global_cleanup(); + + delete Easy::sHandleMutex; + Easy::sHandleMutex = NULL; + delete Easy::sMultiMutex; + Easy::sMultiMutex = NULL; + + for (std::set<CURL*>::iterator iter = Easy::sFreeHandles.begin(); iter != Easy::sFreeHandles.end(); ++iter) + { + CURL* curl = *iter; + curl_easy_cleanup(curl); + } + + Easy::sFreeHandles.clear(); + + llassert(Easy::sActiveHandles.empty()); } const unsigned int LLCurl::MAX_REDIRECTS = 5; + +// Provide access to LLCurl free functions outside of llcurl.cpp without polluting the global namespace. +void LLCurlFF::check_easy_code(CURLcode code) +{ + check_curl_code(code); +} +void LLCurlFF::check_multi_code(CURLMcode code) +{ + check_curl_multi_code(code); +} diff --git a/indra/llmessage/llcurl.h b/indra/llmessage/llcurl.h index 64dadd6640..87de202717 100644..100755 --- a/indra/llmessage/llcurl.h +++ b/indra/llmessage/llcurl.h @@ -41,6 +41,7 @@ #include "llbuffer.h" #include "lliopipe.h" #include "llsd.h" +#include "llthread.h" class LLMutex; @@ -55,6 +56,8 @@ public: class Easy; class Multi; + static bool sMultiThreaded; + struct TransferInfo { TransferInfo() : mSizeDownload(0.0), mTotalTime(0.0), mSpeedDownload(0.0) {} @@ -159,7 +162,7 @@ public: /** * @ brief Initialize LLCurl class */ - static void initClass(); + static void initClass(bool multi_threaded = false); /** * @ brief Cleanup LLCurl class @@ -184,6 +187,124 @@ private: static const unsigned int MAX_REDIRECTS; }; +class LLCurl::Easy +{ + LOG_CLASS(Easy); + +private: + Easy(); + +public: + static Easy* getEasy(); + ~Easy(); + + CURL* getCurlHandle() const { return mCurlEasyHandle; } + + void setErrorBuffer(); + void setCA(); + + void setopt(CURLoption option, S32 value); + // These assume the setter does not free value! + void setopt(CURLoption option, void* value); + void setopt(CURLoption option, char* value); + // Copies the string so that it is guaranteed to stick around + void setoptString(CURLoption option, const std::string& value); + + void slist_append(const char* str); + void setHeaders(); + + U32 report(CURLcode); + void getTransferInfo(LLCurl::TransferInfo* info); + + void prepRequest(const std::string& url, const std::vector<std::string>& headers, ResponderPtr, S32 time_out = 0, bool post = false); + + const char* getErrorBuffer(); + + std::stringstream& getInput() { return mInput; } + std::stringstream& getHeaderOutput() { return mHeaderOutput; } + LLIOPipe::buffer_ptr_t& getOutput() { return mOutput; } + const LLChannelDescriptors& getChannels() { return mChannels; } + + void resetState(); + + static CURL* allocEasyHandle(); + static void releaseEasyHandle(CURL* handle); + +private: + friend class LLCurl; + friend class LLCurl::Multi; + + CURL* mCurlEasyHandle; + struct curl_slist* mHeaders; + + std::stringstream mRequest; + LLChannelDescriptors mChannels; + LLIOPipe::buffer_ptr_t mOutput; + std::stringstream mInput; + std::stringstream mHeaderOutput; + char mErrorBuffer[CURL_ERROR_SIZE]; + + // Note: char*'s not strings since we pass pointers to curl + std::vector<char*> mStrings; + + ResponderPtr mResponder; + + static std::set<CURL*> sFreeHandles; + static std::set<CURL*> sActiveHandles; + static LLMutex* sHandleMutex; + static LLMutex* sMultiMutex; +}; + +class LLCurl::Multi : public LLThread +{ + LOG_CLASS(Multi); +public: + + typedef enum + { + PERFORM_STATE_READY=0, + PERFORM_STATE_PERFORMING=1, + PERFORM_STATE_COMPLETED=2 + } ePerformState; + + Multi(); + ~Multi(); + + Easy* allocEasy(); + bool addEasy(Easy* easy); + + void removeEasy(Easy* easy); + + S32 process(); + void perform(); + void doPerform(); + + virtual void run(); + + CURLMsg* info_read(S32* msgs_in_queue); + + S32 mQueued; + S32 mErrorCount; + + S32 mPerformState; + + LLCondition* mSignal; + bool mQuitting; + bool mThreaded; + +private: + void easyFree(Easy*); + + CURLM* mCurlMultiHandle; + + typedef std::set<Easy*> easy_active_list_t; + easy_active_list_t mEasyActiveList; + typedef std::map<CURL*, Easy*> easy_active_map_t; + easy_active_map_t mEasyActiveMap; + typedef std::set<Easy*> easy_free_list_t; + easy_free_list_t mEasyFreeList; +}; + namespace boost { void intrusive_ptr_add_ref(LLCurl::Responder* p); @@ -201,7 +322,9 @@ public: void get(const std::string& url, LLCurl::ResponderPtr responder); bool getByteRange(const std::string& url, const headers_t& headers, S32 offset, S32 length, LLCurl::ResponderPtr responder); - bool post(const std::string& url, const headers_t& headers, const LLSD& data, LLCurl::ResponderPtr responder); + bool post(const std::string& url, const headers_t& headers, const LLSD& data, LLCurl::ResponderPtr responder, S32 time_out = 0); + bool post(const std::string& url, const headers_t& headers, const std::string& data, LLCurl::ResponderPtr responder, S32 time_out = 0); + S32 process(); S32 getQueued(); @@ -215,6 +338,7 @@ private: curlmulti_set_t mMultiSet; LLCurl::Multi* mActiveMulti; S32 mActiveRequestCount; + BOOL mProcessing; U32 mThreadID; // debug }; @@ -233,10 +357,12 @@ public: void slist_append(const char* str); void sendRequest(const std::string& url); void requestComplete(); - S32 perform(); + void perform(); bool getResult(CURLcode* result, LLCurl::TransferInfo* info = NULL); std::string getErrorString(); + LLCurl::Easy* getEasy() const { return mEasy; } + private: CURLMsg* info_read(S32* queue, LLCurl::TransferInfo* info); @@ -247,4 +373,11 @@ private: bool mResultReturned; }; +// Provide access to LLCurl free functions outside of llcurl.cpp without polluting the global namespace. +namespace LLCurlFF +{ + void check_easy_code(CURLcode code); + void check_multi_code(CURLMcode code); +} + #endif // LL_LLCURL_H diff --git a/indra/llmessage/lldatapacker.h b/indra/llmessage/lldatapacker.h index dd9c4eaa38..b0a638c16e 100644 --- a/indra/llmessage/lldatapacker.h +++ b/indra/llmessage/lldatapacker.h @@ -168,10 +168,15 @@ public: S32 getCurrentSize() const { return (S32)(mCurBufferp - mBufferp); } S32 getBufferSize() const { return mBufferSize; } + const U8* getBuffer() const { return mBufferp; } void reset() { mCurBufferp = mBufferp; mWriteEnabled = (mCurBufferp != NULL); } void freeBuffer() { delete [] mBufferp; mBufferp = mCurBufferp = NULL; mBufferSize = 0; mWriteEnabled = FALSE; } void assignBuffer(U8 *bufferp, S32 size) { + if(mBufferp && mBufferp != bufferp) + { + freeBuffer() ; + } mBufferp = bufferp; mCurBufferp = bufferp; mBufferSize = size; diff --git a/indra/llmessage/llfiltersd2xmlrpc.cpp b/indra/llmessage/llfiltersd2xmlrpc.cpp index 812ef7c151..e0ca056a5f 100644 --- a/indra/llmessage/llfiltersd2xmlrpc.cpp +++ b/indra/llmessage/llfiltersd2xmlrpc.cpp @@ -308,6 +308,7 @@ LLFilterSD2XMLRPCResponse::~LLFilterSD2XMLRPCResponse() } +static LLFastTimer::DeclareTimer FTM_PROCESS_SD2XMLRPC_RESPONSE("SD2XMLRPC Response"); // virtual LLIOPipe::EStatus LLFilterSD2XMLRPCResponse::process_impl( const LLChannelDescriptors& channels, @@ -316,6 +317,8 @@ LLIOPipe::EStatus LLFilterSD2XMLRPCResponse::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_SD2XMLRPC_RESPONSE); + PUMP_DEBUG; // This pipe does not work if it does not have everyting. This // could be addressed by making a stream parser for llsd which @@ -382,6 +385,8 @@ LLFilterSD2XMLRPCRequest::~LLFilterSD2XMLRPCRequest() { } +static LLFastTimer::DeclareTimer FTM_PROCESS_SD2XMLRPC_REQUEST("S22XMLRPC Request"); + // virtual LLIOPipe::EStatus LLFilterSD2XMLRPCRequest::process_impl( const LLChannelDescriptors& channels, @@ -390,6 +395,7 @@ LLIOPipe::EStatus LLFilterSD2XMLRPCRequest::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_SD2XMLRPC_REQUEST); // This pipe does not work if it does not have everyting. This // could be addressed by making a stream parser for llsd which // handled partial information. @@ -586,6 +592,8 @@ LLFilterXMLRPCResponse2LLSD::~LLFilterXMLRPCResponse2LLSD() { } +static LLFastTimer::DeclareTimer FTM_PROCESS_XMLRPC2LLSD_RESPONSE("XMLRPC2LLSD Response"); + LLIOPipe::EStatus LLFilterXMLRPCResponse2LLSD::process_impl( const LLChannelDescriptors& channels, buffer_ptr_t& buffer, @@ -593,6 +601,8 @@ LLIOPipe::EStatus LLFilterXMLRPCResponse2LLSD::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_XMLRPC2LLSD_RESPONSE); + PUMP_DEBUG; if(!eos) return STATUS_BREAK; if(!buffer) return STATUS_ERROR; @@ -668,6 +678,7 @@ LLFilterXMLRPCRequest2LLSD::~LLFilterXMLRPCRequest2LLSD() { } +static LLFastTimer::DeclareTimer FTM_PROCESS_XMLRPC2LLSD_REQUEST("XMLRPC2LLSD Request"); LLIOPipe::EStatus LLFilterXMLRPCRequest2LLSD::process_impl( const LLChannelDescriptors& channels, buffer_ptr_t& buffer, @@ -675,6 +686,7 @@ LLIOPipe::EStatus LLFilterXMLRPCRequest2LLSD::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_XMLRPC2LLSD_REQUEST); PUMP_DEBUG; if(!eos) return STATUS_BREAK; if(!buffer) return STATUS_ERROR; diff --git a/indra/llmessage/llhttpassetstorage.cpp b/indra/llmessage/llhttpassetstorage.cpp index 9ea2ff4153..2bca517e97 100644 --- a/indra/llmessage/llhttpassetstorage.cpp +++ b/indra/llmessage/llhttpassetstorage.cpp @@ -33,6 +33,7 @@ #include "indra_constants.h" #include "message.h" +#include "llproxy.h" #include "llvfile.h" #include "llvfs.h" @@ -174,8 +175,8 @@ LLSD LLHTTPAssetRequest::getFullDetails() const double curl_total_time = -1.0f; double curl_size_upload = -1.0f; double curl_size_download = -1.0f; - long curl_content_length_upload = -1; - long curl_content_length_download = -1; + double curl_content_length_upload = -1.0f; + double curl_content_length_download = -1.0f; long curl_request_size = -1; const char* curl_content_type = NULL; @@ -194,8 +195,8 @@ LLSD LLHTTPAssetRequest::getFullDetails() const sd["curl_total_time"] = curl_total_time; sd["curl_size_upload"] = curl_size_upload; sd["curl_size_download"] = curl_size_download; - sd["curl_content_length_upload"] = (int) curl_content_length_upload; - sd["curl_content_length_download"] = (int) curl_content_length_download; + sd["curl_content_length_upload"] = curl_content_length_upload; + sd["curl_content_length_download"] = curl_content_length_download; sd["curl_request_size"] = (int) curl_request_size; if (curl_content_type) { @@ -232,6 +233,10 @@ void LLHTTPAssetRequest::setupCurlHandle() { // *NOTE: Similar code exists in mapserver/llcurlutil.cpp JC mCurlHandle = curl_easy_init(); + + // Apply proxy settings if configured to do so + LLProxy::getInstance()->applyProxySettings(mCurlHandle); + curl_easy_setopt(mCurlHandle, CURLOPT_NOSIGNAL, 1); curl_easy_setopt(mCurlHandle, CURLOPT_NOPROGRESS, 1); curl_easy_setopt(mCurlHandle, CURLOPT_URL, mURLBuffer.c_str()); diff --git a/indra/llmessage/llhttpclient.cpp b/indra/llmessage/llhttpclient.cpp index 0e5206a520..dd4e3a6300 100644 --- a/indra/llmessage/llhttpclient.cpp +++ b/indra/llmessage/llhttpclient.cpp @@ -428,6 +428,9 @@ static LLSD blocking_request( std::string body_str; // other request method checks root cert first, we skip? + + // Apply configured proxy settings + LLProxy::getInstance()->applyProxySettings(curlp); // * Set curl handle options curl_easy_setopt(curlp, CURLOPT_NOSIGNAL, 1); // don't use SIGALRM for timeouts @@ -436,7 +439,7 @@ static LLSD blocking_request( curl_easy_setopt(curlp, CURLOPT_WRITEDATA, &http_buffer); curl_easy_setopt(curlp, CURLOPT_URL, url.c_str()); curl_easy_setopt(curlp, CURLOPT_ERRORBUFFER, curl_error_buffer); - + // * Setup headers (don't forget to free them after the call!) curl_slist* headers_list = NULL; if (headers.isMap()) diff --git a/indra/llmessage/lliohttpserver.cpp b/indra/llmessage/lliohttpserver.cpp index 3b18a9177c..73e8a69085 100644 --- a/indra/llmessage/lliohttpserver.cpp +++ b/indra/llmessage/lliohttpserver.cpp @@ -140,6 +140,7 @@ private: LLSD mHeaders; }; +static LLFastTimer::DeclareTimer FTM_PROCESS_HTTP_PIPE("HTTP Pipe"); LLIOPipe::EStatus LLHTTPPipe::process_impl( const LLChannelDescriptors& channels, buffer_ptr_t& buffer, @@ -147,6 +148,7 @@ LLIOPipe::EStatus LLHTTPPipe::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_HTTP_PIPE); PUMP_DEBUG; lldebugs << "LLSDHTTPServer::process_impl" << llendl; @@ -428,6 +430,9 @@ protected: /** * LLHTTPResponseHeader */ + +static LLFastTimer::DeclareTimer FTM_PROCESS_HTTP_HEADER("HTTP Header"); + // virtual LLIOPipe::EStatus LLHTTPResponseHeader::process_impl( const LLChannelDescriptors& channels, @@ -436,6 +441,7 @@ LLIOPipe::EStatus LLHTTPResponseHeader::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_HTTP_HEADER); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_HTTP_SERVER); if(eos) @@ -630,6 +636,8 @@ void LLHTTPResponder::markBad( << "</body>\n</html>\n"; } +static LLFastTimer::DeclareTimer FTM_PROCESS_HTTP_RESPONDER("HTTP Responder"); + // virtual LLIOPipe::EStatus LLHTTPResponder::process_impl( const LLChannelDescriptors& channels, @@ -638,6 +646,7 @@ LLIOPipe::EStatus LLHTTPResponder::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_HTTP_RESPONDER); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_HTTP_SERVER); LLIOPipe::EStatus status = STATUS_OK; diff --git a/indra/llmessage/lliosocket.cpp b/indra/llmessage/lliosocket.cpp index ca84fa8bb8..54ceab3422 100644 --- a/indra/llmessage/lliosocket.cpp +++ b/indra/llmessage/lliosocket.cpp @@ -191,7 +191,7 @@ LLSocket::ptr_t LLSocket::create(apr_pool_t* pool, EType type, U16 port) port = PORT_EPHEMERAL; } rv->mPort = port; - rv->setOptions(); + rv->setNonBlocking(); return rv; } @@ -206,7 +206,7 @@ LLSocket::ptr_t LLSocket::create(apr_socket_t* socket, apr_pool_t* pool) } rv = ptr_t(new LLSocket(socket, pool)); rv->mPort = PORT_EPHEMERAL; - rv->setOptions(); + rv->setNonBlocking(); return rv; } @@ -227,10 +227,10 @@ bool LLSocket::blockingConnect(const LLHost& host) { return false; } - apr_socket_timeout_set(mSocket, 1000); + setBlocking(1000); ll_debug_socket("Blocking connect", mSocket); if(ll_apr_warn_status(apr_socket_connect(mSocket, sa))) return false; - setOptions(); + setNonBlocking(); return true; } @@ -251,6 +251,7 @@ LLSocket::~LLSocket() { ll_debug_socket("Destroying socket", mSocket); apr_socket_close(mSocket); + mSocket = NULL; } if(mPool) { @@ -258,11 +259,27 @@ LLSocket::~LLSocket() } } -void LLSocket::setOptions() +// See http://dev.ariel-networks.com/apr/apr-tutorial/html/apr-tutorial-13.html#ss13.4 +// for an explanation of how to get non-blocking sockets and timeouts with +// consistent behavior across platforms. + +void LLSocket::setBlocking(S32 timeout) +{ + LLMemType m1(LLMemType::MTYPE_IO_TCP); + // set up the socket options + ll_apr_warn_status(apr_socket_timeout_set(mSocket, timeout)); + ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_NONBLOCK, 0)); + ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_SNDBUF, LL_SEND_BUFFER_SIZE)); + ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_RCVBUF, LL_RECV_BUFFER_SIZE)); + +} + +void LLSocket::setNonBlocking() { LLMemType m1(LLMemType::MTYPE_IO_TCP); // set up the socket options ll_apr_warn_status(apr_socket_timeout_set(mSocket, 0)); + ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_NONBLOCK, 1)); ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_SNDBUF, LL_SEND_BUFFER_SIZE)); ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_RCVBUF, LL_RECV_BUFFER_SIZE)); @@ -285,6 +302,8 @@ LLIOSocketReader::~LLIOSocketReader() //lldebugs << "Destroying LLIOSocketReader" << llendl; } +static LLFastTimer::DeclareTimer FTM_PROCESS_SOCKET_READER("Socket Reader"); + // virtual LLIOPipe::EStatus LLIOSocketReader::process_impl( const LLChannelDescriptors& channels, @@ -293,6 +312,7 @@ LLIOPipe::EStatus LLIOSocketReader::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_SOCKET_READER); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_TCP); if(!mSource) return STATUS_PRECONDITION_NOT_MET; @@ -385,6 +405,7 @@ LLIOSocketWriter::~LLIOSocketWriter() //lldebugs << "Destroying LLIOSocketWriter" << llendl; } +static LLFastTimer::DeclareTimer FTM_PROCESS_SOCKET_WRITER("Socket Writer"); // virtual LLIOPipe::EStatus LLIOSocketWriter::process_impl( const LLChannelDescriptors& channels, @@ -393,6 +414,7 @@ LLIOPipe::EStatus LLIOSocketWriter::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_SOCKET_WRITER); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_TCP); if(!mDestination) return STATUS_PRECONDITION_NOT_MET; @@ -539,6 +561,7 @@ void LLIOServerSocket::setResponseTimeout(F32 timeout_secs) mResponseTimeout = timeout_secs; } +static LLFastTimer::DeclareTimer FTM_PROCESS_SERVER_SOCKET("Server Socket"); // virtual LLIOPipe::EStatus LLIOServerSocket::process_impl( const LLChannelDescriptors& channels, @@ -547,6 +570,7 @@ LLIOPipe::EStatus LLIOServerSocket::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_SERVER_SOCKET); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_TCP); if(!pump) diff --git a/indra/llmessage/lliosocket.h b/indra/llmessage/lliosocket.h index 6806e5084a..d8ee4e9f98 100644 --- a/indra/llmessage/lliosocket.h +++ b/indra/llmessage/lliosocket.h @@ -145,7 +145,6 @@ public: */ apr_socket_t* getSocket() const { return mSocket; } -protected: /** * @brief Protected constructor since should only make sockets * with one of the two <code>create()</code> calls. @@ -153,9 +152,23 @@ protected: LLSocket(apr_socket_t* socket, apr_pool_t* pool); /** - * @brief Set default socket options. + * @brief Set default socket options, with SO_NONBLOCK = 0 and a timeout in us. + * @param timeout Number of microseconds to wait on this socket. Any + * negative number means block-forever. TIMEOUT OF 0 IS NON-PORTABLE. + */ + void setBlocking(S32 timeout); + + /** + * @brief Set default socket options, with SO_NONBLOCK = 1 and timeout = 0. */ - void setOptions(); + void setNonBlocking(); + +protected: + /** + * @brief Protected constructor since should only make sockets + * with one of the two <code>create()</code> calls. + */ + LLSocket(apr_socket_t* socket, apr_pool_t* pool); public: /** diff --git a/indra/llmessage/llioutil.cpp b/indra/llmessage/llioutil.cpp index 2e6ee59ff2..8c50fd5069 100644 --- a/indra/llmessage/llioutil.cpp +++ b/indra/llmessage/llioutil.cpp @@ -43,6 +43,8 @@ LLIOPipe::EStatus LLIOFlush::process_impl( return STATUS_OK; } + +static LLFastTimer::DeclareTimer FTM_PROCESS_SLEEP("IO Sleep"); /** * @class LLIOSleep */ @@ -53,6 +55,7 @@ LLIOPipe::EStatus LLIOSleep::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_SLEEP); if(mSeconds > 0.0) { if(pump) pump->sleepChain(mSeconds); @@ -62,6 +65,7 @@ LLIOPipe::EStatus LLIOSleep::process_impl( return STATUS_DONE; } +static LLFastTimer::DeclareTimer FTM_PROCESS_ADD_CHAIN("Add Chain"); /** * @class LLIOAddChain */ @@ -72,6 +76,7 @@ LLIOPipe::EStatus LLIOAddChain::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_ADD_CHAIN); pump->addChain(mChain, mTimeout); return STATUS_DONE; } diff --git a/indra/llmessage/llpacketring.cpp b/indra/llmessage/llpacketring.cpp index 8999dec64a..fc6e9c5193 100644 --- a/indra/llmessage/llpacketring.cpp +++ b/indra/llmessage/llpacketring.cpp @@ -28,11 +28,20 @@ #include "llpacketring.h" +#if LL_WINDOWS + #include <winsock2.h> +#else + #include <sys/socket.h> + #include <netinet/in.h> +#endif + // linden library includes #include "llerror.h" #include "lltimer.h" -#include "timing.h" +#include "llproxy.h" #include "llrand.h" +#include "message.h" +#include "timing.h" #include "u64.h" /////////////////////////////////////////////////////////// @@ -216,8 +225,32 @@ S32 LLPacketRing::receivePacket (S32 socket, char *datap) else { // no delay, pull straight from net - packet_size = receive_packet(socket, datap); - mLastSender = ::get_sender(); + if (LLProxy::isSOCKSProxyEnabled()) + { + U8 buffer[NET_BUFFER_SIZE + SOCKS_HEADER_SIZE]; + packet_size = receive_packet(socket, static_cast<char*>(static_cast<void*>(buffer))); + + if (packet_size > SOCKS_HEADER_SIZE) + { + // *FIX We are assuming ATYP is 0x01 (IPv4), not 0x03 (hostname) or 0x04 (IPv6) + memcpy(datap, buffer + SOCKS_HEADER_SIZE, packet_size - SOCKS_HEADER_SIZE); + proxywrap_t * header = static_cast<proxywrap_t*>(static_cast<void*>(buffer)); + mLastSender.setAddress(header->addr); + mLastSender.setPort(ntohs(header->port)); + + packet_size -= SOCKS_HEADER_SIZE; // The unwrapped packet size + } + else + { + packet_size = 0; + } + } + else + { + packet_size = receive_packet(socket, datap); + mLastSender = ::get_sender(); + } + mLastReceivingIF = ::get_receiving_interface(); if (packet_size) // did we actually get a packet? @@ -243,7 +276,7 @@ BOOL LLPacketRing::sendPacket(int h_socket, char * send_buffer, S32 buf_size, LL BOOL status = TRUE; if (!mUseOutThrottle) { - return send_packet(h_socket, send_buffer, buf_size, host.getAddress(), host.getPort() ); + return sendPacketImpl(h_socket, send_buffer, buf_size, host ); } else { @@ -264,7 +297,7 @@ BOOL LLPacketRing::sendPacket(int h_socket, char * send_buffer, S32 buf_size, LL mOutBufferLength -= packetp->getSize(); packet_size = packetp->getSize(); - status = send_packet(h_socket, packetp->getData(), packet_size, packetp->getHost().getAddress(), packetp->getHost().getPort()); + status = sendPacketImpl(h_socket, packetp->getData(), packet_size, packetp->getHost()); delete packetp; // Update the throttle @@ -273,7 +306,7 @@ BOOL LLPacketRing::sendPacket(int h_socket, char * send_buffer, S32 buf_size, LL else { // If the queue's empty, we can just send this packet right away. - status = send_packet(h_socket, send_buffer, buf_size, host.getAddress(), host.getPort() ); + status = sendPacketImpl(h_socket, send_buffer, buf_size, host ); packet_size = buf_size; // Update the throttle @@ -311,3 +344,29 @@ BOOL LLPacketRing::sendPacket(int h_socket, char * send_buffer, S32 buf_size, LL return status; } + +BOOL LLPacketRing::sendPacketImpl(int h_socket, const char * send_buffer, S32 buf_size, LLHost host) +{ + + if (!LLProxy::isSOCKSProxyEnabled()) + { + return send_packet(h_socket, send_buffer, buf_size, host.getAddress(), host.getPort()); + } + + char headered_send_buffer[NET_BUFFER_SIZE + SOCKS_HEADER_SIZE]; + + proxywrap_t *socks_header = static_cast<proxywrap_t*>(static_cast<void*>(&headered_send_buffer)); + socks_header->rsv = 0; + socks_header->addr = host.getAddress(); + socks_header->port = htons(host.getPort()); + socks_header->atype = ADDRESS_IPV4; + socks_header->frag = 0; + + memcpy(headered_send_buffer + SOCKS_HEADER_SIZE, send_buffer, buf_size); + + return send_packet( h_socket, + headered_send_buffer, + buf_size + SOCKS_HEADER_SIZE, + LLProxy::getInstance()->getUDPProxy().getAddress(), + LLProxy::getInstance()->getUDPProxy().getPort()); +} diff --git a/indra/llmessage/llpacketring.h b/indra/llmessage/llpacketring.h index e6409d2048..b214271e78 100644 --- a/indra/llmessage/llpacketring.h +++ b/indra/llmessage/llpacketring.h @@ -30,11 +30,11 @@ #include <queue> -#include "llpacketbuffer.h" #include "llhost.h" -#include "net.h" +#include "llpacketbuffer.h" +#include "llproxy.h" #include "llthrottle.h" - +#include "net.h" class LLPacketRing { @@ -82,6 +82,9 @@ protected: LLHost mLastSender; LLHost mLastReceivingIF; + +private: + BOOL sendPacketImpl(int h_socket, const char * send_buffer, S32 buf_size, LLHost host); }; diff --git a/indra/llmessage/llproxy.cpp b/indra/llmessage/llproxy.cpp new file mode 100644 index 0000000000..4a7d326c0e --- /dev/null +++ b/indra/llmessage/llproxy.cpp @@ -0,0 +1,546 @@ +/** + * @file llproxy.cpp + * @brief UDP and HTTP proxy communications + * + * $LicenseInfo:firstyear=2011&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2011, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#include "linden_common.h" + +#include "llproxy.h" + +#include <string> +#include <curl/curl.h> + +#include "llapr.h" +#include "llcurl.h" +#include "llhost.h" + +// Static class variable instances + +// We want this to be static to avoid excessive indirection on every +// incoming packet just to do a simple bool test. The getter for this +// member is also static +bool LLProxy::sUDPProxyEnabled = false; + +// Some helpful TCP static functions. +static apr_status_t tcp_blocking_handshake(LLSocket::ptr_t handle, char * dataout, apr_size_t outlen, char * datain, apr_size_t maxinlen); // Do a TCP data handshake +static LLSocket::ptr_t tcp_open_channel(LLHost host); // Open a TCP channel to a given host +static void tcp_close_channel(LLSocket::ptr_t* handle_ptr); // Close an open TCP channel + +LLProxy::LLProxy(): + mHTTPProxyEnabled(false), + mProxyMutex(), + mUDPProxy(), + mTCPProxy(), + mHTTPProxy(), + mProxyType(LLPROXY_SOCKS), + mAuthMethodSelected(METHOD_NOAUTH), + mSocksUsername(), + mSocksPassword() +{ +} + +LLProxy::~LLProxy() +{ + stopSOCKSProxy(); + disableHTTPProxy(); +} + +/** + * @brief Open the SOCKS 5 TCP control channel. + * + * Perform a SOCKS 5 authentication and UDP association with the proxy server. + * + * @param proxy The SOCKS 5 server to connect to. + * @return SOCKS_OK if successful, otherwise a socks error code from llproxy.h. + */ +S32 LLProxy::proxyHandshake(LLHost proxy) +{ + S32 result; + + /* SOCKS 5 Auth request */ + socks_auth_request_t socks_auth_request; + socks_auth_response_t socks_auth_response; + + socks_auth_request.version = SOCKS_VERSION; // SOCKS version 5 + socks_auth_request.num_methods = 1; // Sending 1 method. + socks_auth_request.methods = getSelectedAuthMethod(); // Send only the selected method. + + result = tcp_blocking_handshake(mProxyControlChannel, + static_cast<char*>(static_cast<void*>(&socks_auth_request)), + sizeof(socks_auth_request), + static_cast<char*>(static_cast<void*>(&socks_auth_response)), + sizeof(socks_auth_response)); + if (result != APR_SUCCESS) + { + LL_WARNS("Proxy") << "SOCKS authentication request failed, error on TCP control channel : " << result << LL_ENDL; + stopSOCKSProxy(); + return SOCKS_CONNECT_ERROR; + } + + if (socks_auth_response.method == AUTH_NOT_ACCEPTABLE) + { + LL_WARNS("Proxy") << "SOCKS 5 server refused all our authentication methods." << LL_ENDL; + stopSOCKSProxy(); + return SOCKS_NOT_ACCEPTABLE; + } + + /* SOCKS 5 USERNAME/PASSWORD authentication */ + if (socks_auth_response.method == METHOD_PASSWORD) + { + // The server has requested a username/password combination + std::string socks_username(getSocksUser()); + std::string socks_password(getSocksPwd()); + U32 request_size = socks_username.size() + socks_password.size() + 3; + char * password_auth = new char[request_size]; + password_auth[0] = 0x01; + password_auth[1] = socks_username.size(); + memcpy(&password_auth[2], socks_username.c_str(), socks_username.size()); + password_auth[socks_username.size() + 2] = socks_password.size(); + memcpy(&password_auth[socks_username.size() + 3], socks_password.c_str(), socks_password.size()); + + authmethod_password_reply_t password_reply; + + result = tcp_blocking_handshake(mProxyControlChannel, + password_auth, + request_size, + static_cast<char*>(static_cast<void*>(&password_reply)), + sizeof(password_reply)); + delete[] password_auth; + + if (result != APR_SUCCESS) + { + LL_WARNS("Proxy") << "SOCKS authentication failed, error on TCP control channel : " << result << LL_ENDL; + stopSOCKSProxy(); + return SOCKS_CONNECT_ERROR; + } + + if (password_reply.status != AUTH_SUCCESS) + { + LL_WARNS("Proxy") << "SOCKS authentication failed" << LL_ENDL; + stopSOCKSProxy(); + return SOCKS_AUTH_FAIL; + } + } + + /* SOCKS5 connect request */ + + socks_command_request_t connect_request; + socks_command_response_t connect_reply; + + connect_request.version = SOCKS_VERSION; // SOCKS V5 + connect_request.command = COMMAND_UDP_ASSOCIATE; // Associate UDP + connect_request.reserved = FIELD_RESERVED; + connect_request.atype = ADDRESS_IPV4; + connect_request.address = htonl(0); // 0.0.0.0 + connect_request.port = htons(0); // 0 + // "If the client is not in possession of the information at the time of the UDP ASSOCIATE, + // the client MUST use a port number and address of all zeros. RFC 1928" + + result = tcp_blocking_handshake(mProxyControlChannel, + static_cast<char*>(static_cast<void*>(&connect_request)), + sizeof(connect_request), + static_cast<char*>(static_cast<void*>(&connect_reply)), + sizeof(connect_reply)); + if (result != APR_SUCCESS) + { + LL_WARNS("Proxy") << "SOCKS connect request failed, error on TCP control channel : " << result << LL_ENDL; + stopSOCKSProxy(); + return SOCKS_CONNECT_ERROR; + } + + if (connect_reply.reply != REPLY_REQUEST_GRANTED) + { + LL_WARNS("Proxy") << "Connection to SOCKS 5 server failed, UDP forward request not granted" << LL_ENDL; + stopSOCKSProxy(); + return SOCKS_UDP_FWD_NOT_GRANTED; + } + + mUDPProxy.setPort(ntohs(connect_reply.port)); // reply port is in network byte order + mUDPProxy.setAddress(proxy.getAddress()); + // The connection was successful. We now have the UDP port to send requests that need forwarding to. + LL_INFOS("Proxy") << "SOCKS 5 UDP proxy connected on " << mUDPProxy << LL_ENDL; + + return SOCKS_OK; +} + +/** + * @brief Initiates a SOCKS 5 proxy session. + * + * Performs basic checks on host to verify that it is a valid address. Opens the control channel + * and then negotiates the proxy connection with the server. Closes any existing SOCKS + * connection before proceeding. Also disables an HTTP proxy if it is using SOCKS as the proxy. + * + * + * @param host Socks server to connect to. + * @return SOCKS_OK if successful, otherwise a SOCKS error code defined in llproxy.h. + */ +S32 LLProxy::startSOCKSProxy(LLHost host) +{ + if (host.isOk()) + { + mTCPProxy = host; + } + else + { + return SOCKS_INVALID_HOST; + } + + // Close any running SOCKS connection. + stopSOCKSProxy(); + + mProxyControlChannel = tcp_open_channel(mTCPProxy); + if (!mProxyControlChannel) + { + return SOCKS_HOST_CONNECT_FAILED; + } + + S32 status = proxyHandshake(mTCPProxy); + + if (status != SOCKS_OK) + { + // Shut down the proxy if any of the above steps failed. + stopSOCKSProxy(); + } + else + { + // Connection was successful. + sUDPProxyEnabled = true; + } + + return status; +} + +/** + * @brief Stop using the SOCKS 5 proxy. + * + * This will stop sending UDP packets through the SOCKS 5 proxy + * and will also stop the HTTP proxy if it is configured to use SOCKS. + * The proxy control channel will also be disconnected. + */ +void LLProxy::stopSOCKSProxy() +{ + sUDPProxyEnabled = false; + + // If the SOCKS proxy is requested to stop and we are using that for HTTP as well + // then we must shut down any HTTP proxy operations. But it is allowable if web + // proxy is being used to continue proxying HTTP. + + if (LLPROXY_SOCKS == getHTTPProxyType()) + { + disableHTTPProxy(); + } + + if (mProxyControlChannel) + { + tcp_close_channel(&mProxyControlChannel); + } +} + +/** + * @brief Set the proxy's SOCKS authentication method to none. + */ +void LLProxy::setAuthNone() +{ + LLMutexLock lock(&mProxyMutex); + + mAuthMethodSelected = METHOD_NOAUTH; +} + +/** + * @brief Set the proxy's SOCKS authentication method to password. + * + * Check whether the lengths of the supplied username + * and password conform to the lengths allowed by the + * SOCKS protocol. + * + * @param username The SOCKS username to send. + * @param password The SOCKS password to send. + * @return Return true if applying the settings was successful. No changes are made if false. + * + */ +bool LLProxy::setAuthPassword(const std::string &username, const std::string &password) +{ + if (username.length() > SOCKSMAXUSERNAMELEN || password.length() > SOCKSMAXPASSWORDLEN || + username.length() < SOCKSMINUSERNAMELEN || password.length() < SOCKSMINPASSWORDLEN) + { + LL_WARNS("Proxy") << "Invalid SOCKS 5 password or username length." << LL_ENDL; + return false; + } + + LLMutexLock lock(&mProxyMutex); + + mAuthMethodSelected = METHOD_PASSWORD; + mSocksUsername = username; + mSocksPassword = password; + + return true; +} + +/** + * @brief Enable the HTTP proxy for either SOCKS or HTTP. + * + * Check the supplied host to see if it is a valid IP and port. + * + * @param httpHost Proxy server to connect to. + * @param type Is the host a SOCKS or HTTP proxy. + * @return Return true if applying the setting was successful. No changes are made if false. + */ +bool LLProxy::enableHTTPProxy(LLHost httpHost, LLHttpProxyType type) +{ + if (!httpHost.isOk()) + { + LL_WARNS("Proxy") << "Invalid SOCKS 5 Server" << LL_ENDL; + return false; + } + + LLMutexLock lock(&mProxyMutex); + + mHTTPProxy = httpHost; + mProxyType = type; + + mHTTPProxyEnabled = true; + + return true; +} + +/** + * @brief Enable the HTTP proxy without changing the proxy settings. + * + * This should not be called unless the proxy has already been set up. + * + * @return Return true only if the current settings are valid and the proxy was enabled. + */ +bool LLProxy::enableHTTPProxy() +{ + bool ok; + + LLMutexLock lock(&mProxyMutex); + + ok = (mHTTPProxy.isOk()); + if (ok) + { + mHTTPProxyEnabled = true; + } + + return ok; +} + +/** + * @brief Disable the HTTP proxy. + */ +void LLProxy::disableHTTPProxy() +{ + LLMutexLock lock(&mProxyMutex); + + mHTTPProxyEnabled = false; +} + +/** + * @brief Get the currently selected HTTP proxy type + */ +LLHttpProxyType LLProxy::getHTTPProxyType() const +{ + LLMutexLock lock(&mProxyMutex); + return mProxyType; +} + +/** + * @brief Get the SOCKS 5 password. + */ +std::string LLProxy::getSocksPwd() const +{ + LLMutexLock lock(&mProxyMutex); + return mSocksPassword; +} + +/** + * @brief Get the SOCKS 5 username. + */ +std::string LLProxy::getSocksUser() const +{ + LLMutexLock lock(&mProxyMutex); + return mSocksUsername; +} + +/** + * @brief Get the currently selected SOCKS 5 authentication method. + * + * @return Returns either none or password. + */ +LLSocks5AuthType LLProxy::getSelectedAuthMethod() const +{ + LLMutexLock lock(&mProxyMutex); + return mAuthMethodSelected; +} + +/** + * @brief Stop the LLProxy and make certain that any APR pools and classes are deleted before terminating APR. + * + * Deletes the LLProxy singleton, destroying the APR pool used by the control channel as well as . + */ +//static +void LLProxy::cleanupClass() +{ + getInstance()->stopSOCKSProxy(); + deleteSingleton(); +} + +void LLProxy::applyProxySettings(LLCurlEasyRequest* handle) +{ + applyProxySettings(handle->getEasy()); +} + +void LLProxy::applyProxySettings(LLCurl::Easy* handle) +{ + applyProxySettings(handle->getCurlHandle()); +} + +/** + * @brief Apply proxy settings to a CuRL request if an HTTP proxy is enabled. + * + * This method has been designed to be safe to call from + * any thread in the viewer. This allows requests in the + * texture fetch thread to be aware of the proxy settings. + * When the HTTP proxy is enabled, the proxy mutex will + * be locked every time this method is called. + * + * @param handle A pointer to a valid CURL request, before it has been performed. + */ +void LLProxy::applyProxySettings(CURL* handle) +{ + // Do a faster unlocked check to see if we are supposed to proxy. + if (mHTTPProxyEnabled) + { + // We think we should proxy, lock the proxy mutex. + LLMutexLock lock(&mProxyMutex); + // Now test again to verify that the proxy wasn't disabled between the first check and the lock. + if (mHTTPProxyEnabled) + { + LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXY, mHTTPProxy.getIPString().c_str())); + LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXYPORT, mHTTPProxy.getPort())); + + if (mProxyType == LLPROXY_SOCKS) + { + LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5)); + if (mAuthMethodSelected == METHOD_PASSWORD) + { + std::string auth_string = mSocksUsername + ":" + mSocksPassword; + LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXYUSERPWD, auth_string.c_str())); + } + } + else + { + LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP)); + } + } + } +} + +/** + * @brief Send one TCP packet and receive one in return. + * + * This operation is done synchronously with a 1000ms timeout. Therefore, it should not be used when a blocking + * operation would impact the operation of the viewer. + * + * @param handle_ptr Pointer to a connected LLSocket of type STREAM_TCP. + * @param dataout Data to send. + * @param outlen Length of dataout. + * @param datain Buffer for received data. Undefined if return value is not APR_SUCCESS. + * @param maxinlen Maximum possible length of received data. Short reads are allowed. + * @return Indicates APR status code of exchange. APR_SUCCESS if exchange was successful, -1 if invalid data length was received. + */ +static apr_status_t tcp_blocking_handshake(LLSocket::ptr_t handle, char * dataout, apr_size_t outlen, char * datain, apr_size_t maxinlen) +{ + apr_socket_t* apr_socket = handle->getSocket(); + apr_status_t rv = APR_SUCCESS; + + apr_size_t expected_len = outlen; + + handle->setBlocking(1000); + + rv = apr_socket_send(apr_socket, dataout, &outlen); + if (APR_SUCCESS != rv) + { + LL_WARNS("Proxy") << "Error sending data to proxy control channel, status: " << rv << LL_ENDL; + ll_apr_warn_status(rv); + } + else if (expected_len != outlen) + { + LL_WARNS("Proxy") << "Incorrect data length sent. Expected: " << expected_len << + " Sent: " << outlen << LL_ENDL; + rv = -1; + } + + if (APR_SUCCESS == rv) + { + expected_len = maxinlen; + rv = apr_socket_recv(apr_socket, datain, &maxinlen); + if (rv != APR_SUCCESS) + { + LL_WARNS("Proxy") << "Error receiving data from proxy control channel, status: " << rv << LL_ENDL; + ll_apr_warn_status(rv); + } + else if (expected_len < maxinlen) + { + LL_WARNS("Proxy") << "Incorrect data length received. Expected: " << expected_len << + " Received: " << maxinlen << LL_ENDL; + rv = -1; + } + } + + handle->setNonBlocking(); + + return rv; +} + +/** + * @brief Open a LLSocket and do a blocking connect to the chosen host. + * + * Checks for a successful connection, and makes sure the connection is closed if it fails. + * + * @param host The host to open the connection to. + * @return The created socket. Will evaluate as NULL if the connection is unsuccessful. + */ +static LLSocket::ptr_t tcp_open_channel(LLHost host) +{ + LLSocket::ptr_t socket = LLSocket::create(LLSocket::STREAM_TCP); + bool connected = socket->blockingConnect(host); + if (!connected) + { + tcp_close_channel(&socket); + } + + return socket; +} + +/** + * @brief Close the socket. + * + * @param handle_ptr The handle of the socket being closed. A pointer-to-pointer to avoid increasing the use count. + */ +static void tcp_close_channel(LLSocket::ptr_t* handle_ptr) +{ + LL_DEBUGS("Proxy") << "Resetting proxy LLSocket handle, use_count == " << handle_ptr->use_count() << LL_ENDL; + handle_ptr->reset(); +} diff --git a/indra/llmessage/llproxy.h b/indra/llmessage/llproxy.h new file mode 100644 index 0000000000..a919370540 --- /dev/null +++ b/indra/llmessage/llproxy.h @@ -0,0 +1,352 @@ +/** + * @file llproxy.h + * @brief UDP and HTTP proxy communications + * + * $LicenseInfo:firstyear=2011&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2011, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#ifndef LL_PROXY_H +#define LL_PROXY_H + +#include "llcurl.h" +#include "llhost.h" +#include "lliosocket.h" +#include "llmemory.h" +#include "llsingleton.h" +#include "llthread.h" +#include <string> + +// SOCKS error codes returned from the StartProxy method +#define SOCKS_OK 0 +#define SOCKS_CONNECT_ERROR (-1) +#define SOCKS_NOT_PERMITTED (-2) +#define SOCKS_NOT_ACCEPTABLE (-3) +#define SOCKS_AUTH_FAIL (-4) +#define SOCKS_UDP_FWD_NOT_GRANTED (-5) +#define SOCKS_HOST_CONNECT_FAILED (-6) +#define SOCKS_INVALID_HOST (-7) + +#ifndef MAXHOSTNAMELEN +#define MAXHOSTNAMELEN (255 + 1) /* socks5: 255, +1 for len. */ +#endif + +#define SOCKSMAXUSERNAMELEN 255 +#define SOCKSMAXPASSWORDLEN 255 + +#define SOCKSMINUSERNAMELEN 1 +#define SOCKSMINPASSWORDLEN 1 + +#define SOCKS_VERSION 0x05 // we are using SOCKS 5 + +#define SOCKS_HEADER_SIZE 10 + +// SOCKS 5 address/hostname types +#define ADDRESS_IPV4 0x01 +#define ADDRESS_HOSTNAME 0x03 +#define ADDRESS_IPV6 0x04 + +// Lets just use our own ipv4 struct rather than dragging in system +// specific headers +union ipv4_address_t { + U8 octets[4]; + U32 addr32; +}; + +// SOCKS 5 control channel commands +#define COMMAND_TCP_STREAM 0x01 +#define COMMAND_TCP_BIND 0x02 +#define COMMAND_UDP_ASSOCIATE 0x03 + +// SOCKS 5 command replies +#define REPLY_REQUEST_GRANTED 0x00 +#define REPLY_GENERAL_FAIL 0x01 +#define REPLY_RULESET_FAIL 0x02 +#define REPLY_NETWORK_UNREACHABLE 0x03 +#define REPLY_HOST_UNREACHABLE 0x04 +#define REPLY_CONNECTION_REFUSED 0x05 +#define REPLY_TTL_EXPIRED 0x06 +#define REPLY_PROTOCOL_ERROR 0x07 +#define REPLY_TYPE_NOT_SUPPORTED 0x08 + +#define FIELD_RESERVED 0x00 + +// The standard SOCKS 5 request packet +// Push current alignment to stack and set alignment to 1 byte boundary +// This enabled us to use structs directly to set up and receive network packets +// into the correct fields, without fear of boundary alignment causing issues +#pragma pack(push,1) + +// SOCKS 5 command packet +struct socks_command_request_t { + U8 version; + U8 command; + U8 reserved; + U8 atype; + U32 address; + U16 port; +}; + +// Standard SOCKS 5 reply packet +struct socks_command_response_t { + U8 version; + U8 reply; + U8 reserved; + U8 atype; + U8 add_bytes[4]; + U16 port; +}; + +#define AUTH_NOT_ACCEPTABLE 0xFF // reply if preferred methods are not available +#define AUTH_SUCCESS 0x00 // reply if authentication successful + +// SOCKS 5 authentication request, stating which methods the client supports +struct socks_auth_request_t { + U8 version; + U8 num_methods; + U8 methods; // We are only using a single method currently +}; + +// SOCKS 5 authentication response packet, stating server preferred method +struct socks_auth_response_t { + U8 version; + U8 method; +}; + +// SOCKS 5 password reply packet +struct authmethod_password_reply_t { + U8 version; + U8 status; +}; + +// SOCKS 5 UDP packet header +struct proxywrap_t { + U16 rsv; + U8 frag; + U8 atype; + U32 addr; + U16 port; +}; + +#pragma pack(pop) /* restore original alignment from stack */ + + +// Currently selected HTTP proxy type +enum LLHttpProxyType +{ + LLPROXY_SOCKS = 0, + LLPROXY_HTTP = 1 +}; + +// Auth types +enum LLSocks5AuthType +{ + METHOD_NOAUTH = 0x00, // Client supports no auth + METHOD_GSSAPI = 0x01, // Client supports GSSAPI (Not currently supported) + METHOD_PASSWORD = 0x02 // Client supports username/password +}; + +/** + * @brief Manage SOCKS 5 UDP proxy and HTTP proxy. + * + * This class is responsible for managing two interconnected tasks, + * connecting to a SOCKS 5 proxy for use by LLPacketRing to send UDP + * packets and managing proxy settings for HTTP requests. + * + * <h1>Threading:</h1> + * Because HTTP requests can be generated in threads outside the + * main thread, it is necessary for some of the information stored + * by this class to be available to other threads. The members that + * need to be read across threads are in a labeled section below. + * To protect those members, a mutex, mProxyMutex should be locked + * before reading or writing those members. Methods that can lock + * mProxyMutex are in a labeled section below. Those methods should + * not be called while the mutex is already locked. + * + * There is also a LLAtomic type flag (mHTTPProxyEnabled) that is used + * to track whether the HTTP proxy is currently enabled. This allows + * for faster unlocked checks to see if the proxy is enabled. This + * allows us to cut down on the performance hit when the proxy is + * disabled compared to before this class was introduced. + * + * <h1>UDP Proxying:</h1> + * UDP datagrams are proxied via a SOCKS 5 proxy with the UDP associate + * command. To initiate the proxy, a TCP socket connection is opened + * to the SOCKS 5 host, and after a handshake exchange, the server + * returns a port and address to send the UDP traffic that is to be + * proxied to. The LLProxy class tracks this address and port after the + * exchange and provides it to LLPacketRing when required to. All UDP + * proxy management occurs in the main thread. + * + * <h1>HTTP Proxying:</h1> + * This class allows all viewer HTTP packets to be sent through a proxy. + * The user can select whether to send HTTP packets through a standard + * "web" HTTP proxy, through a SOCKS 5 proxy, or to not proxy HTTP + * communication. This class does not manage the integrated web browser + * proxy, which is handled in llviewermedia.cpp. + * + * The implementation of HTTP proxying is handled by libcurl. LLProxy + * is responsible for managing the HTTP proxy options and provides a + * thread-safe method to apply those options to a curl request + * (LLProxy::applyProxySettings()). This method is overloaded + * to accommodate the various abstraction libcurl layers that exist + * throughout the viewer (LLCurlEasyRequest, LLCurl::Easy, and CURL). + * + * If you are working with LLCurl or LLCurlEasyRequest objects, + * the configured proxy settings will be applied in the constructors + * of those request handles. If you are working with CURL objects + * directly, you will need to pass the handle of the request to + * applyProxySettings() before issuing the request. + * + * To ensure thread safety, all LLProxy members that relate to the HTTP + * proxy require the LLProxyMutex to be locked before accessing. + */ +class LLProxy: public LLSingleton<LLProxy> +{ + LOG_CLASS(LLProxy); +public: + /*########################################################################################### + METHODS THAT DO NOT LOCK mProxyMutex! + ###########################################################################################*/ + // Constructor, cannot have parameters due to LLSingleton parent class. Call from main thread only. + LLProxy(); + + // Static check for enabled status for UDP packets. Call from main thread only. + static bool isSOCKSProxyEnabled() { return sUDPProxyEnabled; } + + // Get the UDP proxy address and port. Call from main thread only. + LLHost getUDPProxy() const { return mUDPProxy; } + + /*########################################################################################### + END OF NON-LOCKING METHODS + ###########################################################################################*/ + + /*########################################################################################### + METHODS THAT LOCK mProxyMutex! DO NOT CALL WHILE mProxyMutex IS LOCKED! + ###########################################################################################*/ + // Destructor, closes open connections. Do not call directly, use cleanupClass(). + ~LLProxy(); + + // Delete LLProxy singleton. Allows the apr_socket used in the SOCKS 5 control channel to be + // destroyed before the call to apr_terminate. Call from main thread only. + static void cleanupClass(); + + // Apply the current proxy settings to a curl request. Doesn't do anything if mHTTPProxyEnabled is false. + // Safe to call from any thread. + void applyProxySettings(CURL* handle); + void applyProxySettings(LLCurl::Easy* handle); + void applyProxySettings(LLCurlEasyRequest* handle); + + // Start a connection to the SOCKS 5 proxy. Call from main thread only. + S32 startSOCKSProxy(LLHost host); + + // Disconnect and clean up any connection to the SOCKS 5 proxy. Call from main thread only. + void stopSOCKSProxy(); + + // Use Password auth when connecting to the SOCKS proxy. Call from main thread only. + bool setAuthPassword(const std::string &username, const std::string &password); + + // Disable authentication when connecting to the SOCKS proxy. Call from main thread only. + void setAuthNone(); + + // Proxy HTTP packets via httpHost, which can be a SOCKS 5 or a HTTP proxy. + // as specified in type. Call from main thread only. + bool enableHTTPProxy(LLHost httpHost, LLHttpProxyType type); + bool enableHTTPProxy(); + + // Stop proxying HTTP packets. Call from main thread only. + void disableHTTPProxy(); + + /*########################################################################################### + END OF LOCKING METHODS + ###########################################################################################*/ +private: + /*########################################################################################### + METHODS THAT LOCK mProxyMutex! DO NOT CALL WHILE mProxyMutex IS LOCKED! + ###########################################################################################*/ + + // Perform a SOCKS 5 authentication and UDP association with the proxy server. + S32 proxyHandshake(LLHost proxy); + + // Get the currently selected auth method. + LLSocks5AuthType getSelectedAuthMethod() const; + + // Get the currently selected HTTP proxy type + LLHttpProxyType getHTTPProxyType() const; + + std::string getSocksPwd() const; + std::string getSocksUser() const; + + /*########################################################################################### + END OF LOCKING METHODS + ###########################################################################################*/ + +private: + // Is the HTTP proxy enabled? Safe to read in any thread, but do not write directly. + // Instead use enableHTTPProxy() and disableHTTPProxy() instead. + mutable LLAtomic32<bool> mHTTPProxyEnabled; + + // Mutex to protect shared members in non-main thread calls to applyProxySettings(). + mutable LLMutex mProxyMutex; + + /*########################################################################################### + MEMBERS READ AND WRITTEN ONLY IN THE MAIN THREAD. DO NOT SHARE! + ###########################################################################################*/ + + // Is the UDP proxy enabled? + static bool sUDPProxyEnabled; + + // UDP proxy address and port + LLHost mUDPProxy; + // TCP proxy control channel address and port + LLHost mTCPProxy; + + // socket handle to proxy TCP control channel + LLSocket::ptr_t mProxyControlChannel; + + /*########################################################################################### + END OF UNSHARED MEMBERS + ###########################################################################################*/ + + /*########################################################################################### + MEMBERS WRITTEN IN MAIN THREAD AND READ IN ANY THREAD. ONLY READ OR WRITE AFTER LOCKING mProxyMutex! + ###########################################################################################*/ + + // HTTP proxy address and port + LLHost mHTTPProxy; + + // Currently selected HTTP proxy type. Can be web or socks. + LLHttpProxyType mProxyType; + + // SOCKS 5 selected authentication method. + LLSocks5AuthType mAuthMethodSelected; + + // SOCKS 5 username + std::string mSocksUsername; + // SOCKS 5 password + std::string mSocksPassword; + + /*########################################################################################### + END OF SHARED MEMBERS + ###########################################################################################*/ +}; + +#endif diff --git a/indra/llmessage/llsdmessagebuilder.cpp b/indra/llmessage/llsdmessagebuilder.cpp index 42c179782f..2698a271ee 100644 --- a/indra/llmessage/llsdmessagebuilder.cpp +++ b/indra/llmessage/llsdmessagebuilder.cpp @@ -29,6 +29,7 @@ #include "llsdmessagebuilder.h" #include "llmessagetemplate.h" +#include "llmath.h" #include "llquaternion.h" #include "llsdutil.h" #include "llsdutil_math.h" diff --git a/indra/llmessage/llsdrpcclient.cpp b/indra/llmessage/llsdrpcclient.cpp index 86fe5c7912..91fd070f07 100644 --- a/indra/llmessage/llsdrpcclient.cpp +++ b/indra/llmessage/llsdrpcclient.cpp @@ -82,6 +82,8 @@ bool LLSDRPCResponse::extractResponse(const LLSD& sd) return rv; } +static LLFastTimer::DeclareTimer FTM_SDRPC_RESPONSE("SDRPC Response"); + // virtual LLIOPipe::EStatus LLSDRPCResponse::process_impl( const LLChannelDescriptors& channels, @@ -90,6 +92,7 @@ LLIOPipe::EStatus LLSDRPCResponse::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_SDRPC_RESPONSE); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT); if(mIsError) @@ -178,6 +181,8 @@ bool LLSDRPCClient::call( return true; } +static LLFastTimer::DeclareTimer FTM_PROCESS_SDRPC_CLIENT("SDRPC Client"); + // virtual LLIOPipe::EStatus LLSDRPCClient::process_impl( const LLChannelDescriptors& channels, @@ -186,6 +191,7 @@ LLIOPipe::EStatus LLSDRPCClient::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_SDRPC_CLIENT); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT); if((STATE_NONE == mState) || (!pump)) diff --git a/indra/llmessage/llsdrpcserver.cpp b/indra/llmessage/llsdrpcserver.cpp index f87c418fb1..9f776aca72 100644 --- a/indra/llmessage/llsdrpcserver.cpp +++ b/indra/llmessage/llsdrpcserver.cpp @@ -97,6 +97,8 @@ void LLSDRPCServer::clearLock() } } +static LLFastTimer::DeclareTimer FTM_PROCESS_SDRPC_SERVER("SDRPC Server"); + // virtual LLIOPipe::EStatus LLSDRPCServer::process_impl( const LLChannelDescriptors& channels, @@ -105,6 +107,7 @@ LLIOPipe::EStatus LLSDRPCServer::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_SDRPC_SERVER); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_SD_SERVER); // lldebugs << "LLSDRPCServer::process_impl" << llendl; diff --git a/indra/llmessage/lltemplatemessagebuilder.cpp b/indra/llmessage/lltemplatemessagebuilder.cpp index 6611d704e6..9e8eb48460 100644 --- a/indra/llmessage/lltemplatemessagebuilder.cpp +++ b/indra/llmessage/lltemplatemessagebuilder.cpp @@ -29,6 +29,7 @@ #include "lltemplatemessagebuilder.h" #include "llmessagetemplate.h" +#include "llmath.h" #include "llquaternion.h" #include "u64.h" #include "v3dmath.h" diff --git a/indra/llmessage/lltemplatemessagereader.cpp b/indra/llmessage/lltemplatemessagereader.cpp index 3bfcd58c69..ab91f74abe 100644 --- a/indra/llmessage/lltemplatemessagereader.cpp +++ b/indra/llmessage/lltemplatemessagereader.cpp @@ -30,6 +30,7 @@ #include "llfasttimer.h" #include "llmessagebuilder.h" #include "llmessagetemplate.h" +#include "llmath.h" #include "llquaternion.h" #include "message.h" #include "u64.h" @@ -794,7 +795,7 @@ const char* LLTemplateMessageReader::getMessageName() const { if (!mCurrentRMessageTemplate) { - llwarns << "no mCurrentRMessageTemplate" << llendl; + // no message currently being read return ""; } return mCurrentRMessageTemplate->mName; diff --git a/indra/llmessage/lltransfermanager.cpp b/indra/llmessage/lltransfermanager.cpp index 754eb99cbd..034680caf8 100644 --- a/indra/llmessage/lltransfermanager.cpp +++ b/indra/llmessage/lltransfermanager.cpp @@ -338,7 +338,7 @@ void LLTransferManager::processTransferInfo(LLMessageSystem *msgp, void **) } } - llinfos << "Receiving " << transfer_id << ", size " << size << " bytes" << llendl; + //llinfos << "Receiving " << transfer_id << ", size " << size << " bytes" << llendl; ttp->setSize(size); ttp->setGotInfo(TRUE); diff --git a/indra/llmessage/lltransfersourceasset.cpp b/indra/llmessage/lltransfersourceasset.cpp index 7e57841580..8537773a3f 100644 --- a/indra/llmessage/lltransfersourceasset.cpp +++ b/indra/llmessage/lltransfersourceasset.cpp @@ -251,3 +251,4 @@ BOOL LLTransferSourceParamsAsset::unpackParams(LLDataPacker &dp) return TRUE; } + diff --git a/indra/llmessage/llurlrequest.cpp b/indra/llmessage/llurlrequest.cpp index cb9d1c3731..fa03bb7512 100644 --- a/indra/llmessage/llurlrequest.cpp +++ b/indra/llmessage/llurlrequest.cpp @@ -35,6 +35,7 @@ #include "llcurl.h" #include "llioutil.h" #include "llmemtype.h" +#include "llproxy.h" #include "llpumpio.h" #include "llsd.h" #include "llstring.h" @@ -270,6 +271,8 @@ LLIOPipe::EStatus LLURLRequest::handleError( return status; } +static LLFastTimer::DeclareTimer FTM_PROCESS_URL_REQUEST("URL Request"); + // virtual LLIOPipe::EStatus LLURLRequest::process_impl( const LLChannelDescriptors& channels, @@ -278,6 +281,7 @@ LLIOPipe::EStatus LLURLRequest::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_URL_REQUEST); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST); //llinfos << "LLURLRequest::process_impl()" << llendl; @@ -288,6 +292,8 @@ LLIOPipe::EStatus LLURLRequest::process_impl( const S32 MIN_ACCUMULATION = 100000; if(pump && (mDetail->mByteAccumulator > MIN_ACCUMULATION)) { + static LLFastTimer::DeclareTimer FTM_URL_ADJUST_TIMEOUT("Adjust Timeout"); + LLFastTimer t(FTM_URL_ADJUST_TIMEOUT); // This is a pretty sloppy calculation, but this // tries to make the gross assumption that if data // is coming in at 56kb/s, then this transfer will @@ -335,16 +341,30 @@ LLIOPipe::EStatus LLURLRequest::process_impl( { PUMP_DEBUG; LLIOPipe::EStatus status = STATUS_BREAK; - mDetail->mCurlRequest->perform(); + static LLFastTimer::DeclareTimer FTM_URL_PERFORM("Perform"); + { + LLFastTimer t(FTM_URL_PERFORM); + mDetail->mCurlRequest->perform(); + } + while(1) { CURLcode result; - bool newmsg = mDetail->mCurlRequest->getResult(&result); + + static LLFastTimer::DeclareTimer FTM_PROCESS_URL_REQUEST_GET_RESULT("Get Result"); + + bool newmsg = false; + { + LLFastTimer t(FTM_PROCESS_URL_REQUEST_GET_RESULT); + newmsg = mDetail->mCurlRequest->getResult(&result); + } + if(!newmsg) { // keep processing break; } + mState = STATE_HAVE_RESPONSE; context[CONTEXT_REQUEST][CONTEXT_TRANSFERED_BYTES] = mRequestTransferedBytes; @@ -370,7 +390,11 @@ LLIOPipe::EStatus LLURLRequest::process_impl( link.mChannels = LLBufferArray::makeChannelConsumer( channels); chain.push_back(link); - pump->respond(chain, buffer, context); + static LLFastTimer::DeclareTimer FTM_PROCESS_URL_PUMP_RESPOND("Pump Respond"); + { + LLFastTimer t(FTM_PROCESS_URL_PUMP_RESPOND); + pump->respond(chain, buffer, context); + } mCompletionCallback = NULL; } break; @@ -422,8 +446,11 @@ void LLURLRequest::initialize() mResponseTransferedBytes = 0; } +static LLFastTimer::DeclareTimer FTM_URL_REQUEST_CONFIGURE("URL Configure"); bool LLURLRequest::configure() { + LLFastTimer t(FTM_URL_REQUEST_CONFIGURE); + LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST); bool rv = false; S32 bytes = mDetail->mResponseBuffer->countAfter( @@ -440,6 +467,9 @@ bool LLURLRequest::configure() case HTTP_GET: mDetail->mCurlRequest->setopt(CURLOPT_HTTPGET, 1); mDetail->mCurlRequest->setopt(CURLOPT_FOLLOWLOCATION, 1); + + // Set Accept-Encoding to allow response compression + mDetail->mCurlRequest->setoptString(CURLOPT_ENCODING, ""); rv = true; break; @@ -464,6 +494,9 @@ bool LLURLRequest::configure() // Set the handle for an http post mDetail->mCurlRequest->setPost(NULL, bytes); + + // Set Accept-Encoding to allow response compression + mDetail->mCurlRequest->setoptString(CURLOPT_ENCODING, ""); rv = true; break; @@ -618,6 +651,7 @@ static size_t headerCallback(void* data, size_t size, size_t nmemb, void* user) return header_len; } +static LLFastTimer::DeclareTimer FTM_PROCESS_URL_EXTRACTOR("URL Extractor"); /** * LLContextURLExtractor */ @@ -629,6 +663,7 @@ LLIOPipe::EStatus LLContextURLExtractor::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_URL_EXTRACTOR); PUMP_DEBUG; LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST); // The destination host is in the context. @@ -707,6 +742,7 @@ void LLURLRequestComplete::responseStatus(LLIOPipe::EStatus status) mRequestStatus = status; } +static LLFastTimer::DeclareTimer FTM_PROCESS_URL_COMPLETE("URL Complete"); // virtual LLIOPipe::EStatus LLURLRequestComplete::process_impl( const LLChannelDescriptors& channels, @@ -715,6 +751,7 @@ LLIOPipe::EStatus LLURLRequestComplete::process_impl( LLSD& context, LLPumpIO* pump) { + LLFastTimer t(FTM_PROCESS_URL_COMPLETE); PUMP_DEBUG; complete(channels, buffer); return STATUS_OK; diff --git a/indra/llmessage/message.cpp b/indra/llmessage/message.cpp index 2f0d815be5..d0b0e178b8 100644 --- a/indra/llmessage/message.cpp +++ b/indra/llmessage/message.cpp @@ -2441,12 +2441,12 @@ void dump_prehash_files() " * Generated from message template version number %.3f\n" " */\n", gMessageSystem->mMessageFileVersionNumber); - fprintf(fp, "\n\nextern F32 gPrehashVersionNumber;\n\n"); + fprintf(fp, "\n\nextern F32 const gPrehashVersionNumber;\n\n"); for (i = 0; i < MESSAGE_NUMBER_OF_HASH_BUCKETS; i++) { if (!LLMessageStringTable::getInstance()->mEmpty[i] && LLMessageStringTable::getInstance()->mString[i][0] != '.') { - fprintf(fp, "extern char * _PREHASH_%s;\n", LLMessageStringTable::getInstance()->mString[i]); + fprintf(fp, "extern char const* const _PREHASH_%s;\n", LLMessageStringTable::getInstance()->mString[i]); } } fprintf(fp, "\n\n#endif\n"); @@ -2471,12 +2471,12 @@ void dump_prehash_files() gMessageSystem->mMessageFileVersionNumber); fprintf(fp, "#include \"linden_common.h\"\n"); fprintf(fp, "#include \"message.h\"\n\n"); - fprintf(fp, "\n\nF32 gPrehashVersionNumber = %.3ff;\n\n", gMessageSystem->mMessageFileVersionNumber); + fprintf(fp, "\n\nF32 const gPrehashVersionNumber = %.3ff;\n\n", gMessageSystem->mMessageFileVersionNumber); for (i = 0; i < MESSAGE_NUMBER_OF_HASH_BUCKETS; i++) { if (!LLMessageStringTable::getInstance()->mEmpty[i] && LLMessageStringTable::getInstance()->mString[i][0] != '.') { - fprintf(fp, "char * _PREHASH_%s = LLMessageStringTable::getInstance()->getString(\"%s\");\n", LLMessageStringTable::getInstance()->mString[i], LLMessageStringTable::getInstance()->mString[i]); + fprintf(fp, "char const* const _PREHASH_%s = LLMessageStringTable::getInstance()->getString(\"%s\");\n", LLMessageStringTable::getInstance()->mString[i], LLMessageStringTable::getInstance()->mString[i]); } } fclose(fp); diff --git a/indra/llmessage/message_prehash.cpp b/indra/llmessage/message_prehash.cpp index eb1e366149..e71fb96540 100644 --- a/indra/llmessage/message_prehash.cpp +++ b/indra/llmessage/message_prehash.cpp @@ -32,1346 +32,1350 @@ -F32 gPrehashVersionNumber = 2.000f; +F32 const gPrehashVersionNumber = 2.000f; -char* _PREHASH_X = LLMessageStringTable::getInstance()->getString("X"); -char* _PREHASH_Y = LLMessageStringTable::getInstance()->getString("Y"); -char* _PREHASH_Z = LLMessageStringTable::getInstance()->getString("Z"); -char* _PREHASH_AddFlags = LLMessageStringTable::getInstance()->getString("AddFlags"); -char* _PREHASH_FailureInfo = LLMessageStringTable::getInstance()->getString("FailureInfo"); -char* _PREHASH_MapData = LLMessageStringTable::getInstance()->getString("MapData"); -char* _PREHASH_AddItem = LLMessageStringTable::getInstance()->getString("AddItem"); -char* _PREHASH_MeanCollision = LLMessageStringTable::getInstance()->getString("MeanCollision"); -char* _PREHASH_RezScript = LLMessageStringTable::getInstance()->getString("RezScript"); -char* _PREHASH_AvatarSitResponse = LLMessageStringTable::getInstance()->getString("AvatarSitResponse"); -char* _PREHASH_InventoryAssetResponse = LLMessageStringTable::getInstance()->getString("InventoryAssetResponse"); -char* _PREHASH_KillObject = LLMessageStringTable::getInstance()->getString("KillObject"); -char* _PREHASH_ProposalID = LLMessageStringTable::getInstance()->getString("ProposalID"); -char* _PREHASH_SerialNum = LLMessageStringTable::getInstance()->getString("SerialNum"); -char* _PREHASH_Duration = LLMessageStringTable::getInstance()->getString("Duration"); -char* _PREHASH_ScriptQuestion = LLMessageStringTable::getInstance()->getString("ScriptQuestion"); -char* _PREHASH_AddCircuitCode = LLMessageStringTable::getInstance()->getString("AddCircuitCode"); -char* _PREHASH_UseCircuitCode = LLMessageStringTable::getInstance()->getString("UseCircuitCode"); -char* _PREHASH_ViewerCircuitCode = LLMessageStringTable::getInstance()->getString("ViewerCircuitCode"); -char* _PREHASH_ScriptAnswerYes = LLMessageStringTable::getInstance()->getString("ScriptAnswerYes"); -char* _PREHASH_PartnerID = LLMessageStringTable::getInstance()->getString("PartnerID"); -char* _PREHASH_DirLandQuery = LLMessageStringTable::getInstance()->getString("DirLandQuery"); -char* _PREHASH_TeleportStart = LLMessageStringTable::getInstance()->getString("TeleportStart"); -char* _PREHASH_AboutText = LLMessageStringTable::getInstance()->getString("AboutText"); -char* _PREHASH_VisualParam = LLMessageStringTable::getInstance()->getString("VisualParam"); -char* _PREHASH_GroupPrims = LLMessageStringTable::getInstance()->getString("GroupPrims"); -char* _PREHASH_SelectedPrims = LLMessageStringTable::getInstance()->getString("SelectedPrims"); -char* _PREHASH_ID = LLMessageStringTable::getInstance()->getString("ID"); -char* _PREHASH_UUIDNameRequest = LLMessageStringTable::getInstance()->getString("UUIDNameRequest"); -char* _PREHASH_UUIDGroupNameRequest = LLMessageStringTable::getInstance()->getString("UUIDGroupNameRequest"); -char* _PREHASH_GroupAccountTransactionsRequest = LLMessageStringTable::getInstance()->getString("GroupAccountTransactionsRequest"); -char* _PREHASH_MapNameRequest = LLMessageStringTable::getInstance()->getString("MapNameRequest"); -char* _PREHASH_UpdateSimulator = LLMessageStringTable::getInstance()->getString("UpdateSimulator"); -char* _PREHASH_BillableFactor = LLMessageStringTable::getInstance()->getString("BillableFactor"); -char* _PREHASH_ObjectBonusFactor = LLMessageStringTable::getInstance()->getString("ObjectBonusFactor"); -char* _PREHASH_EnableSimulator = LLMessageStringTable::getInstance()->getString("EnableSimulator"); -char* _PREHASH_DisableSimulator = LLMessageStringTable::getInstance()->getString("DisableSimulator"); -char* _PREHASH_ConfirmEnableSimulator = LLMessageStringTable::getInstance()->getString("ConfirmEnableSimulator"); -char* _PREHASH_LayerType = LLMessageStringTable::getInstance()->getString("LayerType"); -char* _PREHASH_OwnerRole = LLMessageStringTable::getInstance()->getString("OwnerRole"); -char* _PREHASH_ParcelOverlay = LLMessageStringTable::getInstance()->getString("ParcelOverlay"); -char* _PREHASH_GroupOwned = LLMessageStringTable::getInstance()->getString("GroupOwned"); -char* _PREHASH_IP = LLMessageStringTable::getInstance()->getString("IP"); -char* _PREHASH_ChatFromViewer = LLMessageStringTable::getInstance()->getString("ChatFromViewer"); -char* _PREHASH_AvgAgentsInView = LLMessageStringTable::getInstance()->getString("AvgAgentsInView"); -char* _PREHASH_AgentsInView = LLMessageStringTable::getInstance()->getString("AgentsInView"); -char* _PREHASH_GroupTitle = LLMessageStringTable::getInstance()->getString("GroupTitle"); -char* _PREHASH_MapLayerReply = LLMessageStringTable::getInstance()->getString("MapLayerReply"); -char* _PREHASH_CompoundMsgID = LLMessageStringTable::getInstance()->getString("CompoundMsgID"); -char* _PREHASH_CameraConstraint = LLMessageStringTable::getInstance()->getString("CameraConstraint"); -char* _PREHASH_DownloadTotals = LLMessageStringTable::getInstance()->getString("DownloadTotals"); -char* _PREHASH_GenCounter = LLMessageStringTable::getInstance()->getString("GenCounter"); -char* _PREHASH_FrozenData = LLMessageStringTable::getInstance()->getString("FrozenData"); -char* _PREHASH_ChildAgentDying = LLMessageStringTable::getInstance()->getString("ChildAgentDying"); -char* _PREHASH_To = LLMessageStringTable::getInstance()->getString("To"); -char* _PREHASH_CopyInventoryFromNotecard = LLMessageStringTable::getInstance()->getString("CopyInventoryFromNotecard"); -char* _PREHASH_RezObjectFromNotecard = LLMessageStringTable::getInstance()->getString("RezObjectFromNotecard"); -char* _PREHASH_ParcelDirFeeCurrent = LLMessageStringTable::getInstance()->getString("ParcelDirFeeCurrent"); -char* _PREHASH_SeedCapability = LLMessageStringTable::getInstance()->getString("SeedCapability"); -char* _PREHASH_ObjectDuplicate = LLMessageStringTable::getInstance()->getString("ObjectDuplicate"); -char* _PREHASH_InventoryData = LLMessageStringTable::getInstance()->getString("InventoryData"); -char* _PREHASH_ReplyData = LLMessageStringTable::getInstance()->getString("ReplyData"); -char* _PREHASH_ResetList = LLMessageStringTable::getInstance()->getString("ResetList"); -char* _PREHASH_MediaID = LLMessageStringTable::getInstance()->getString("MediaID"); -char* _PREHASH_RelatedRights = LLMessageStringTable::getInstance()->getString("RelatedRights"); -char* _PREHASH_RedirectGridX = LLMessageStringTable::getInstance()->getString("RedirectGridX"); -char* _PREHASH_RedirectGridY = LLMessageStringTable::getInstance()->getString("RedirectGridY"); -char* _PREHASH_TransferID = LLMessageStringTable::getInstance()->getString("TransferID"); -char* _PREHASH_TexturesChanged = LLMessageStringTable::getInstance()->getString("TexturesChanged"); -char* _PREHASH_UserLookAt = LLMessageStringTable::getInstance()->getString("UserLookAt"); -char* _PREHASH_TestBlock1 = LLMessageStringTable::getInstance()->getString("TestBlock1"); -char* _PREHASH_SensedData = LLMessageStringTable::getInstance()->getString("SensedData"); -char* _PREHASH_UpdateBlock = LLMessageStringTable::getInstance()->getString("UpdateBlock"); -char* _PREHASH_ClassifiedGodDelete = LLMessageStringTable::getInstance()->getString("ClassifiedGodDelete"); -char* _PREHASH_ObjectGrabUpdate = LLMessageStringTable::getInstance()->getString("ObjectGrabUpdate"); -char* _PREHASH_LocationPos = LLMessageStringTable::getInstance()->getString("LocationPos"); -char* _PREHASH_TaxDate = LLMessageStringTable::getInstance()->getString("TaxDate"); -char* _PREHASH_StartDateTime = LLMessageStringTable::getInstance()->getString("StartDateTime"); -char* _PREHASH_ObjectUpdateCached = LLMessageStringTable::getInstance()->getString("ObjectUpdateCached"); -char* _PREHASH_Packets = LLMessageStringTable::getInstance()->getString("Packets"); -char* _PREHASH_FailureType = LLMessageStringTable::getInstance()->getString("FailureType"); -char* _PREHASH_UpdateGroupInfo = LLMessageStringTable::getInstance()->getString("UpdateGroupInfo"); -char* _PREHASH_ObjectPermissions = LLMessageStringTable::getInstance()->getString("ObjectPermissions"); -char* _PREHASH_RevokePermissions = LLMessageStringTable::getInstance()->getString("RevokePermissions"); -char* _PREHASH_UpdateFlags = LLMessageStringTable::getInstance()->getString("UpdateFlags"); -char* _PREHASH_ObjectExportSelected = LLMessageStringTable::getInstance()->getString("ObjectExportSelected"); -char* _PREHASH_RezSelected = LLMessageStringTable::getInstance()->getString("RezSelected"); -char* _PREHASH_AutoPilot = LLMessageStringTable::getInstance()->getString("AutoPilot"); -char* _PREHASH_UpdateMuteListEntry = LLMessageStringTable::getInstance()->getString("UpdateMuteListEntry"); -char* _PREHASH_RemoveMuteListEntry = LLMessageStringTable::getInstance()->getString("RemoveMuteListEntry"); -char* _PREHASH_SetSimStatusInDatabase = LLMessageStringTable::getInstance()->getString("SetSimStatusInDatabase"); -char* _PREHASH_SetSimPresenceInDatabase = LLMessageStringTable::getInstance()->getString("SetSimPresenceInDatabase"); -char* _PREHASH_CameraProperty = LLMessageStringTable::getInstance()->getString("CameraProperty"); -char* _PREHASH_BrushSize = LLMessageStringTable::getInstance()->getString("BrushSize"); -char* _PREHASH_SimulatorSetMap = LLMessageStringTable::getInstance()->getString("SimulatorSetMap"); -char* _PREHASH_RegionPresenceRequestByRegionID = LLMessageStringTable::getInstance()->getString("RegionPresenceRequestByRegionID"); -char* _PREHASH_ParcelObjectOwnersReply = LLMessageStringTable::getInstance()->getString("ParcelObjectOwnersReply"); -char* _PREHASH_GroupMembersReply = LLMessageStringTable::getInstance()->getString("GroupMembersReply"); -char* _PREHASH_GroupRoleMembersReply = LLMessageStringTable::getInstance()->getString("GroupRoleMembersReply"); -char* _PREHASH_RequestRegionInfo = LLMessageStringTable::getInstance()->getString("RequestRegionInfo"); -char* _PREHASH_AABBMax = LLMessageStringTable::getInstance()->getString("AABBMax"); -char* _PREHASH_RequestPayPrice = LLMessageStringTable::getInstance()->getString("RequestPayPrice"); -char* _PREHASH_SimulatorPresentAtLocation = LLMessageStringTable::getInstance()->getString("SimulatorPresentAtLocation"); -char* _PREHASH_AgentRequestSit = LLMessageStringTable::getInstance()->getString("AgentRequestSit"); -char* _PREHASH_AABBMin = LLMessageStringTable::getInstance()->getString("AABBMin"); -char* _PREHASH_ClassifiedFlags = LLMessageStringTable::getInstance()->getString("ClassifiedFlags"); -char* _PREHASH_ControlFlags = LLMessageStringTable::getInstance()->getString("ControlFlags"); -char* _PREHASH_TeleportRequest = LLMessageStringTable::getInstance()->getString("TeleportRequest"); -char* _PREHASH_ScriptTeleportRequest = LLMessageStringTable::getInstance()->getString("ScriptTeleportRequest"); -char* _PREHASH_EstateCovenantRequest = LLMessageStringTable::getInstance()->getString("EstateCovenantRequest"); -char* _PREHASH_DateUTC = LLMessageStringTable::getInstance()->getString("DateUTC"); -char* _PREHASH_TaskIDs = LLMessageStringTable::getInstance()->getString("TaskIDs"); -char* _PREHASH_RequestResult = LLMessageStringTable::getInstance()->getString("RequestResult"); -char* _PREHASH_CanAcceptAgents = LLMessageStringTable::getInstance()->getString("CanAcceptAgents"); -char* _PREHASH_ObjectSaleInfo = LLMessageStringTable::getInstance()->getString("ObjectSaleInfo"); -char* _PREHASH_KillChildAgents = LLMessageStringTable::getInstance()->getString("KillChildAgents"); -char* _PREHASH_Balance = LLMessageStringTable::getInstance()->getString("Balance"); -char* _PREHASH_DerezContainer = LLMessageStringTable::getInstance()->getString("DerezContainer"); -char* _PREHASH_ObjectData = LLMessageStringTable::getInstance()->getString("ObjectData"); -char* _PREHASH_CameraAtAxis = LLMessageStringTable::getInstance()->getString("CameraAtAxis"); -char* _PREHASH_InfoBlock = LLMessageStringTable::getInstance()->getString("InfoBlock"); -char* _PREHASH_OwnershipCost = LLMessageStringTable::getInstance()->getString("OwnershipCost"); -char* _PREHASH_AvatarNotesUpdate = LLMessageStringTable::getInstance()->getString("AvatarNotesUpdate"); -char* _PREHASH_PID = LLMessageStringTable::getInstance()->getString("PID"); -char* _PREHASH_DirPopularReply = LLMessageStringTable::getInstance()->getString("DirPopularReply"); -char* _PREHASH_TerrainHeightRange00 = LLMessageStringTable::getInstance()->getString("TerrainHeightRange00"); -char* _PREHASH_SimData = LLMessageStringTable::getInstance()->getString("SimData"); -char* _PREHASH_TerrainHeightRange01 = LLMessageStringTable::getInstance()->getString("TerrainHeightRange01"); -char* _PREHASH_TerrainHeightRange10 = LLMessageStringTable::getInstance()->getString("TerrainHeightRange10"); -char* _PREHASH_TerrainHeightRange11 = LLMessageStringTable::getInstance()->getString("TerrainHeightRange11"); -char* _PREHASH_UpdateInventoryItem = LLMessageStringTable::getInstance()->getString("UpdateInventoryItem"); -char* _PREHASH_UpdateCreateInventoryItem = LLMessageStringTable::getInstance()->getString("UpdateCreateInventoryItem"); -char* _PREHASH_MoveInventoryItem = LLMessageStringTable::getInstance()->getString("MoveInventoryItem"); -char* _PREHASH_CopyInventoryItem = LLMessageStringTable::getInstance()->getString("CopyInventoryItem"); -char* _PREHASH_LinkInventoryItem = LLMessageStringTable::getInstance()->getString("LinkInventoryItem"); -char* _PREHASH_RemoveInventoryItem = LLMessageStringTable::getInstance()->getString("RemoveInventoryItem"); -char* _PREHASH_CreateInventoryItem = LLMessageStringTable::getInstance()->getString("CreateInventoryItem"); -char* _PREHASH_PathTwistBegin = LLMessageStringTable::getInstance()->getString("PathTwistBegin"); -char* _PREHASH_CRC = LLMessageStringTable::getInstance()->getString("CRC"); -char* _PREHASH_AttachmentPoint = LLMessageStringTable::getInstance()->getString("AttachmentPoint"); -char* _PREHASH_TelehubBlock = LLMessageStringTable::getInstance()->getString("TelehubBlock"); -char* _PREHASH_FOVBlock = LLMessageStringTable::getInstance()->getString("FOVBlock"); -char* _PREHASH_StartLocationData = LLMessageStringTable::getInstance()->getString("StartLocationData"); -char* _PREHASH_PositionData = LLMessageStringTable::getInstance()->getString("PositionData"); -char* _PREHASH_TimeSinceLast = LLMessageStringTable::getInstance()->getString("TimeSinceLast"); -char* _PREHASH_MapImage = LLMessageStringTable::getInstance()->getString("MapImage"); -char* _PREHASH_Objects = LLMessageStringTable::getInstance()->getString("Objects"); -char* _PREHASH_URL = LLMessageStringTable::getInstance()->getString("URL"); -char* _PREHASH_CreationDate = LLMessageStringTable::getInstance()->getString("CreationDate"); -char* _PREHASH_JointPivot = LLMessageStringTable::getInstance()->getString("JointPivot"); -char* _PREHASH_FPS = LLMessageStringTable::getInstance()->getString("FPS"); -char* _PREHASH_HasTelehub = LLMessageStringTable::getInstance()->getString("HasTelehub"); -char* _PREHASH_PathEnd = LLMessageStringTable::getInstance()->getString("PathEnd"); -char* _PREHASH_ScriptDataReply = LLMessageStringTable::getInstance()->getString("ScriptDataReply"); -char* _PREHASH_MapBlockReply = LLMessageStringTable::getInstance()->getString("MapBlockReply"); -char* _PREHASH_PropertiesData = LLMessageStringTable::getInstance()->getString("PropertiesData"); -char* _PREHASH_ViewerEffect = LLMessageStringTable::getInstance()->getString("ViewerEffect"); -char* _PREHASH_FreezeUser = LLMessageStringTable::getInstance()->getString("FreezeUser"); -char* _PREHASH_OwnerPrims = LLMessageStringTable::getInstance()->getString("OwnerPrims"); -char* _PREHASH_ObjectGrab = LLMessageStringTable::getInstance()->getString("ObjectGrab"); -char* _PREHASH_ToAgentID = LLMessageStringTable::getInstance()->getString("ToAgentID"); -char* _PREHASH_SimulatorMapUpdate = LLMessageStringTable::getInstance()->getString("SimulatorMapUpdate"); -char* _PREHASH_TransferPacket = LLMessageStringTable::getInstance()->getString("TransferPacket"); -char* _PREHASH_ObjectName = LLMessageStringTable::getInstance()->getString("ObjectName"); -char* _PREHASH_GroupPowers = LLMessageStringTable::getInstance()->getString("GroupPowers"); -char* _PREHASH_OriginalName = LLMessageStringTable::getInstance()->getString("OriginalName"); -char* _PREHASH_CompletePingCheck = LLMessageStringTable::getInstance()->getString("CompletePingCheck"); -char* _PREHASH_OnlineStatus = LLMessageStringTable::getInstance()->getString("OnlineStatus"); -char* _PREHASH_ObjectDrop = LLMessageStringTable::getInstance()->getString("ObjectDrop"); -char* _PREHASH_UseBigPackets = LLMessageStringTable::getInstance()->getString("UseBigPackets"); -char* _PREHASH_GroupNoticesListReply = LLMessageStringTable::getInstance()->getString("GroupNoticesListReply"); -char* _PREHASH_ParcelAccessListReply = LLMessageStringTable::getInstance()->getString("ParcelAccessListReply"); -char* _PREHASH_RpcChannelReply = LLMessageStringTable::getInstance()->getString("RpcChannelReply"); -char* _PREHASH_RegionPresenceResponse = LLMessageStringTable::getInstance()->getString("RegionPresenceResponse"); -char* _PREHASH_CharterMember = LLMessageStringTable::getInstance()->getString("CharterMember"); -char* _PREHASH_EdgeData = LLMessageStringTable::getInstance()->getString("EdgeData"); -char* _PREHASH_NameData = LLMessageStringTable::getInstance()->getString("NameData"); -char* _PREHASH_RegionPushOverride = LLMessageStringTable::getInstance()->getString("RegionPushOverride"); -char* _PREHASH_SimName = LLMessageStringTable::getInstance()->getString("SimName"); -char* _PREHASH_UserReport = LLMessageStringTable::getInstance()->getString("UserReport"); -char* _PREHASH_DownloadPriority = LLMessageStringTable::getInstance()->getString("DownloadPriority"); -char* _PREHASH_ToAgentId = LLMessageStringTable::getInstance()->getString("ToAgentId"); -char* _PREHASH_DirPopularQuery = LLMessageStringTable::getInstance()->getString("DirPopularQuery"); -char* _PREHASH_Mag = LLMessageStringTable::getInstance()->getString("Mag"); -char* _PREHASH_ParcelPropertiesRequestByID = LLMessageStringTable::getInstance()->getString("ParcelPropertiesRequestByID"); -char* _PREHASH_ObjectLink = LLMessageStringTable::getInstance()->getString("ObjectLink"); -char* _PREHASH_RpcScriptReplyInbound = LLMessageStringTable::getInstance()->getString("RpcScriptReplyInbound"); -char* _PREHASH_RezData = LLMessageStringTable::getInstance()->getString("RezData"); -char* _PREHASH_RemoveInventoryObjects = LLMessageStringTable::getInstance()->getString("RemoveInventoryObjects"); -char* _PREHASH_GroupProposalBallot = LLMessageStringTable::getInstance()->getString("GroupProposalBallot"); -char* _PREHASH_RPCServerIP = LLMessageStringTable::getInstance()->getString("RPCServerIP"); -char* _PREHASH_Far = LLMessageStringTable::getInstance()->getString("Far"); -char* _PREHASH_GodSessionID = LLMessageStringTable::getInstance()->getString("GodSessionID"); -char* _PREHASH_FLAboutText = LLMessageStringTable::getInstance()->getString("FLAboutText"); -char* _PREHASH_RegionHandshakeReply = LLMessageStringTable::getInstance()->getString("RegionHandshakeReply"); -char* _PREHASH_GroupActiveProposalItemReply = LLMessageStringTable::getInstance()->getString("GroupActiveProposalItemReply"); -char* _PREHASH_MapItemReply = LLMessageStringTable::getInstance()->getString("MapItemReply"); -char* _PREHASH_Seconds = LLMessageStringTable::getInstance()->getString("Seconds"); -char* _PREHASH_UpdateUserInfo = LLMessageStringTable::getInstance()->getString("UpdateUserInfo"); -char* _PREHASH_AggregatePermTexturesOwner = LLMessageStringTable::getInstance()->getString("AggregatePermTexturesOwner"); -char* _PREHASH_Set = LLMessageStringTable::getInstance()->getString("Set"); -char* _PREHASH_NewName = LLMessageStringTable::getInstance()->getString("NewName"); -char* _PREHASH_Key = LLMessageStringTable::getInstance()->getString("Key"); -char* _PREHASH_AgentID = LLMessageStringTable::getInstance()->getString("AgentID"); -char* _PREHASH_EventNotificationRemoveRequest = LLMessageStringTable::getInstance()->getString("EventNotificationRemoveRequest"); -char* _PREHASH_NewFolderID = LLMessageStringTable::getInstance()->getString("NewFolderID"); -char* _PREHASH_Arc = LLMessageStringTable::getInstance()->getString("Arc"); -char* _PREHASH_RegionX = LLMessageStringTable::getInstance()->getString("RegionX"); -char* _PREHASH_RegionY = LLMessageStringTable::getInstance()->getString("RegionY"); -char* _PREHASH_RequestData = LLMessageStringTable::getInstance()->getString("RequestData"); -char* _PREHASH_Msg = LLMessageStringTable::getInstance()->getString("Msg"); -char* _PREHASH_Top = LLMessageStringTable::getInstance()->getString("Top"); -char* _PREHASH_MiscStats = LLMessageStringTable::getInstance()->getString("MiscStats"); -char* _PREHASH_ImageID = LLMessageStringTable::getInstance()->getString("ImageID"); -char* _PREHASH_DataPacket = LLMessageStringTable::getInstance()->getString("DataPacket"); -char* _PREHASH_You = LLMessageStringTable::getInstance()->getString("You"); -char* _PREHASH_ScriptControlChange = LLMessageStringTable::getInstance()->getString("ScriptControlChange"); -char* _PREHASH_LoadURL = LLMessageStringTable::getInstance()->getString("LoadURL"); -char* _PREHASH_SetCPURatio = LLMessageStringTable::getInstance()->getString("SetCPURatio"); -char* _PREHASH_NameValueData = LLMessageStringTable::getInstance()->getString("NameValueData"); -char* _PREHASH_AtomicPassObject = LLMessageStringTable::getInstance()->getString("AtomicPassObject"); -char* _PREHASH_ErrorMessage = LLMessageStringTable::getInstance()->getString("ErrorMessage"); -char* _PREHASH_ViewerFrozenMessage = LLMessageStringTable::getInstance()->getString("ViewerFrozenMessage"); -char* _PREHASH_HealthMessage = LLMessageStringTable::getInstance()->getString("HealthMessage"); -char* _PREHASH_LogTextMessage = LLMessageStringTable::getInstance()->getString("LogTextMessage"); -char* _PREHASH_TimeDilation = LLMessageStringTable::getInstance()->getString("TimeDilation"); -char* _PREHASH_RemoveContribution = LLMessageStringTable::getInstance()->getString("RemoveContribution"); -char* _PREHASH_Contribution = LLMessageStringTable::getInstance()->getString("Contribution"); -char* _PREHASH_SetGroupContribution = LLMessageStringTable::getInstance()->getString("SetGroupContribution"); -char* _PREHASH_Offline = LLMessageStringTable::getInstance()->getString("Offline"); -char* _PREHASH_AgentIsNowWearing = LLMessageStringTable::getInstance()->getString("AgentIsNowWearing"); -char* _PREHASH_Members = LLMessageStringTable::getInstance()->getString("Members"); -char* _PREHASH_FailedResends = LLMessageStringTable::getInstance()->getString("FailedResends"); -char* _PREHASH_SecPerDay = LLMessageStringTable::getInstance()->getString("SecPerDay"); -char* _PREHASH_CameraCenter = LLMessageStringTable::getInstance()->getString("CameraCenter"); -char* _PREHASH_CameraLeftAxis = LLMessageStringTable::getInstance()->getString("CameraLeftAxis"); -char* _PREHASH_ExBlock = LLMessageStringTable::getInstance()->getString("ExBlock"); -char* _PREHASH_Channel = LLMessageStringTable::getInstance()->getString("Channel"); -char* _PREHASH_NetTest = LLMessageStringTable::getInstance()->getString("NetTest"); -char* _PREHASH_DiscardLevel = LLMessageStringTable::getInstance()->getString("DiscardLevel"); -char* _PREHASH_LayerID = LLMessageStringTable::getInstance()->getString("LayerID"); -char* _PREHASH_GrabOffset = LLMessageStringTable::getInstance()->getString("GrabOffset"); -char* _PREHASH_SimPort = LLMessageStringTable::getInstance()->getString("SimPort"); -char* _PREHASH_PricePerMeter = LLMessageStringTable::getInstance()->getString("PricePerMeter"); -char* _PREHASH_RegionFlags = LLMessageStringTable::getInstance()->getString("RegionFlags"); -char* _PREHASH_VoteResult = LLMessageStringTable::getInstance()->getString("VoteResult"); -char* _PREHASH_ParcelDirFeeEstimate = LLMessageStringTable::getInstance()->getString("ParcelDirFeeEstimate"); -char* _PREHASH_ModifyBlock = LLMessageStringTable::getInstance()->getString("ModifyBlock"); -char* _PREHASH_InventoryBlock = LLMessageStringTable::getInstance()->getString("InventoryBlock"); -char* _PREHASH_ReplyBlock = LLMessageStringTable::getInstance()->getString("ReplyBlock"); -char* _PREHASH_ValidUntil = LLMessageStringTable::getInstance()->getString("ValidUntil"); -char* _PREHASH_VelocityInterpolateOn = LLMessageStringTable::getInstance()->getString("VelocityInterpolateOn"); -char* _PREHASH_ClassifiedDelete = LLMessageStringTable::getInstance()->getString("ClassifiedDelete"); -char* _PREHASH_RegionDenyAnonymous = LLMessageStringTable::getInstance()->getString("RegionDenyAnonymous"); -char* _PREHASH_FLImageID = LLMessageStringTable::getInstance()->getString("FLImageID"); -char* _PREHASH_AllowPublish = LLMessageStringTable::getInstance()->getString("AllowPublish"); -char* _PREHASH_SitName = LLMessageStringTable::getInstance()->getString("SitName"); -char* _PREHASH_RegionsVisited = LLMessageStringTable::getInstance()->getString("RegionsVisited"); -char* _PREHASH_DirClassifiedReply = LLMessageStringTable::getInstance()->getString("DirClassifiedReply"); -char* _PREHASH_AvatarClassifiedReply = LLMessageStringTable::getInstance()->getString("AvatarClassifiedReply"); -char* _PREHASH_MediaURL = LLMessageStringTable::getInstance()->getString("MediaURL"); -char* _PREHASH_CompleteAgentMovement = LLMessageStringTable::getInstance()->getString("CompleteAgentMovement"); -char* _PREHASH_ClassifiedID = LLMessageStringTable::getInstance()->getString("ClassifiedID"); -char* _PREHASH_LocalID = LLMessageStringTable::getInstance()->getString("LocalID"); -char* _PREHASH_SpaceIP = LLMessageStringTable::getInstance()->getString("SpaceIP"); -char* _PREHASH_RemoveItem = LLMessageStringTable::getInstance()->getString("RemoveItem"); -char* _PREHASH_LogFailedMoneyTransaction = LLMessageStringTable::getInstance()->getString("LogFailedMoneyTransaction"); -char* _PREHASH_ViewerStartAuction = LLMessageStringTable::getInstance()->getString("ViewerStartAuction"); -char* _PREHASH_StartAuction = LLMessageStringTable::getInstance()->getString("StartAuction"); -char* _PREHASH_DuplicateFlags = LLMessageStringTable::getInstance()->getString("DuplicateFlags"); -char* _PREHASH_RegionInfo2 = LLMessageStringTable::getInstance()->getString("RegionInfo2"); -char* _PREHASH_TextColor = LLMessageStringTable::getInstance()->getString("TextColor"); -char* _PREHASH_SlaveID = LLMessageStringTable::getInstance()->getString("SlaveID"); -char* _PREHASH_Charter = LLMessageStringTable::getInstance()->getString("Charter"); -char* _PREHASH_AlertData = LLMessageStringTable::getInstance()->getString("AlertData"); -char* _PREHASH_AlertInfo = LLMessageStringTable::getInstance()->getString("AlertInfo"); -char* _PREHASH_TargetBlock = LLMessageStringTable::getInstance()->getString("TargetBlock"); -char* _PREHASH_CheckParcelAuctions = LLMessageStringTable::getInstance()->getString("CheckParcelAuctions"); -char* _PREHASH_ParcelAuctions = LLMessageStringTable::getInstance()->getString("ParcelAuctions"); -char* _PREHASH_OwnerIsGroup = LLMessageStringTable::getInstance()->getString("OwnerIsGroup"); -char* _PREHASH_NameValuePair = LLMessageStringTable::getInstance()->getString("NameValuePair"); -char* _PREHASH_RemoveNameValuePair = LLMessageStringTable::getInstance()->getString("RemoveNameValuePair"); -char* _PREHASH_BulkUpdateInventory = LLMessageStringTable::getInstance()->getString("BulkUpdateInventory"); -char* _PREHASH_UpdateTaskInventory = LLMessageStringTable::getInstance()->getString("UpdateTaskInventory"); -char* _PREHASH_RemoveTaskInventory = LLMessageStringTable::getInstance()->getString("RemoveTaskInventory"); -char* _PREHASH_MoveTaskInventory = LLMessageStringTable::getInstance()->getString("MoveTaskInventory"); -char* _PREHASH_RequestTaskInventory = LLMessageStringTable::getInstance()->getString("RequestTaskInventory"); -char* _PREHASH_ReplyTaskInventory = LLMessageStringTable::getInstance()->getString("ReplyTaskInventory"); -char* _PREHASH_AggregatePermInventory = LLMessageStringTable::getInstance()->getString("AggregatePermInventory"); -char* _PREHASH_GroupAccountTransactionsReply = LLMessageStringTable::getInstance()->getString("GroupAccountTransactionsReply"); -char* _PREHASH_SimulatorInfo = LLMessageStringTable::getInstance()->getString("SimulatorInfo"); -char* _PREHASH_WearableData = LLMessageStringTable::getInstance()->getString("WearableData"); -char* _PREHASH_Enabled = LLMessageStringTable::getInstance()->getString("Enabled"); -char* _PREHASH_Savings = LLMessageStringTable::getInstance()->getString("Savings"); -char* _PREHASH_SimulatorLoad = LLMessageStringTable::getInstance()->getString("SimulatorLoad"); -char* _PREHASH_InternalRegionIP = LLMessageStringTable::getInstance()->getString("InternalRegionIP"); -char* _PREHASH_ExternalRegionIP = LLMessageStringTable::getInstance()->getString("ExternalRegionIP"); -char* _PREHASH_TotalPairs = LLMessageStringTable::getInstance()->getString("TotalPairs"); -char* _PREHASH_CreateGroupRequest = LLMessageStringTable::getInstance()->getString("CreateGroupRequest"); -char* _PREHASH_JoinGroupRequest = LLMessageStringTable::getInstance()->getString("JoinGroupRequest"); -char* _PREHASH_LeaveGroupRequest = LLMessageStringTable::getInstance()->getString("LeaveGroupRequest"); -char* _PREHASH_InviteGroupRequest = LLMessageStringTable::getInstance()->getString("InviteGroupRequest"); -char* _PREHASH_LiveHelpGroupRequest = LLMessageStringTable::getInstance()->getString("LiveHelpGroupRequest"); -char* _PREHASH_PriceParcelClaimFactor = LLMessageStringTable::getInstance()->getString("PriceParcelClaimFactor"); -char* _PREHASH_BillableArea = LLMessageStringTable::getInstance()->getString("BillableArea"); -char* _PREHASH_ObjectID = LLMessageStringTable::getInstance()->getString("ObjectID"); -char* _PREHASH_ObjectFlagUpdate = LLMessageStringTable::getInstance()->getString("ObjectFlagUpdate"); -char* _PREHASH_GroupRoleUpdate = LLMessageStringTable::getInstance()->getString("GroupRoleUpdate"); -char* _PREHASH_RequestInventoryAsset = LLMessageStringTable::getInstance()->getString("RequestInventoryAsset"); -char* _PREHASH_ChangedGrid = LLMessageStringTable::getInstance()->getString("ChangedGrid"); -char* _PREHASH_AgentDropGroup = LLMessageStringTable::getInstance()->getString("AgentDropGroup"); -char* _PREHASH_Details = LLMessageStringTable::getInstance()->getString("Details"); -char* _PREHASH_LocationX = LLMessageStringTable::getInstance()->getString("LocationX"); -char* _PREHASH_SaleType = LLMessageStringTable::getInstance()->getString("SaleType"); -char* _PREHASH_LocationY = LLMessageStringTable::getInstance()->getString("LocationY"); -char* _PREHASH_LocationZ = LLMessageStringTable::getInstance()->getString("LocationZ"); -char* _PREHASH_EconomyData = LLMessageStringTable::getInstance()->getString("EconomyData"); -char* _PREHASH_HeadRotation = LLMessageStringTable::getInstance()->getString("HeadRotation"); -char* _PREHASH_DeleteOnCompletion = LLMessageStringTable::getInstance()->getString("DeleteOnCompletion"); -char* _PREHASH_PublicPort = LLMessageStringTable::getInstance()->getString("PublicPort"); -char* _PREHASH_DirClassifiedQuery = LLMessageStringTable::getInstance()->getString("DirClassifiedQuery"); -char* _PREHASH_CallbackID = LLMessageStringTable::getInstance()->getString("CallbackID"); -char* _PREHASH_RequestParcelTransfer = LLMessageStringTable::getInstance()->getString("RequestParcelTransfer"); -char* _PREHASH_RoleCount = LLMessageStringTable::getInstance()->getString("RoleCount"); -char* _PREHASH_ObjectCapacity = LLMessageStringTable::getInstance()->getString("ObjectCapacity"); -char* _PREHASH_RequestID = LLMessageStringTable::getInstance()->getString("RequestID"); -char* _PREHASH_RequestXfer = LLMessageStringTable::getInstance()->getString("RequestXfer"); -char* _PREHASH_ObjectTaxCurrent = LLMessageStringTable::getInstance()->getString("ObjectTaxCurrent"); -char* _PREHASH_LightTaxCurrent = LLMessageStringTable::getInstance()->getString("LightTaxCurrent"); -char* _PREHASH_LandTaxCurrent = LLMessageStringTable::getInstance()->getString("LandTaxCurrent"); -char* _PREHASH_GroupTaxCurrent = LLMessageStringTable::getInstance()->getString("GroupTaxCurrent"); -char* _PREHASH_FetchInventoryDescendents = LLMessageStringTable::getInstance()->getString("FetchInventoryDescendents"); -char* _PREHASH_InventoryDescendents = LLMessageStringTable::getInstance()->getString("InventoryDescendents"); -char* _PREHASH_Descendents = LLMessageStringTable::getInstance()->getString("Descendents"); -char* _PREHASH_PurgeInventoryDescendents = LLMessageStringTable::getInstance()->getString("PurgeInventoryDescendents"); -char* _PREHASH_ShowDir = LLMessageStringTable::getInstance()->getString("ShowDir"); -char* _PREHASH_IsOwner = LLMessageStringTable::getInstance()->getString("IsOwner"); -char* _PREHASH_Timestamp = LLMessageStringTable::getInstance()->getString("Timestamp"); -char* _PREHASH_GlobalPos = LLMessageStringTable::getInstance()->getString("GlobalPos"); -char* _PREHASH_GrabOffsetInitial = LLMessageStringTable::getInstance()->getString("GrabOffsetInitial"); -char* _PREHASH_IsTrial = LLMessageStringTable::getInstance()->getString("IsTrial"); -char* _PREHASH_ObjectDuplicateOnRay = LLMessageStringTable::getInstance()->getString("ObjectDuplicateOnRay"); -char* _PREHASH_GroupMembershipCount = LLMessageStringTable::getInstance()->getString("GroupMembershipCount"); -char* _PREHASH_MethodData = LLMessageStringTable::getInstance()->getString("MethodData"); -char* _PREHASH_ActivateGestures = LLMessageStringTable::getInstance()->getString("ActivateGestures"); -char* _PREHASH_DeactivateGestures = LLMessageStringTable::getInstance()->getString("DeactivateGestures"); -char* _PREHASH_ProposalData = LLMessageStringTable::getInstance()->getString("ProposalData"); -char* _PREHASH_PosGlobal = LLMessageStringTable::getInstance()->getString("PosGlobal"); -char* _PREHASH_SearchID = LLMessageStringTable::getInstance()->getString("SearchID"); -char* _PREHASH_RezMultipleAttachmentsFromInv = LLMessageStringTable::getInstance()->getString("RezMultipleAttachmentsFromInv"); -char* _PREHASH_SearchName = LLMessageStringTable::getInstance()->getString("SearchName"); -char* _PREHASH_VersionString = LLMessageStringTable::getInstance()->getString("VersionString"); -char* _PREHASH_CreateGroupReply = LLMessageStringTable::getInstance()->getString("CreateGroupReply"); -char* _PREHASH_LeaveGroupReply = LLMessageStringTable::getInstance()->getString("LeaveGroupReply"); -char* _PREHASH_ActualArea = LLMessageStringTable::getInstance()->getString("ActualArea"); -char* _PREHASH_Message = LLMessageStringTable::getInstance()->getString("Message"); -char* _PREHASH_ClickAction = LLMessageStringTable::getInstance()->getString("ClickAction"); -char* _PREHASH_AssetUploadComplete = LLMessageStringTable::getInstance()->getString("AssetUploadComplete"); -char* _PREHASH_RequestType = LLMessageStringTable::getInstance()->getString("RequestType"); -char* _PREHASH_UUID = LLMessageStringTable::getInstance()->getString("UUID"); -char* _PREHASH_BaseMask = LLMessageStringTable::getInstance()->getString("BaseMask"); -char* _PREHASH_NetBlock = LLMessageStringTable::getInstance()->getString("NetBlock"); -char* _PREHASH_GlobalX = LLMessageStringTable::getInstance()->getString("GlobalX"); -char* _PREHASH_GlobalY = LLMessageStringTable::getInstance()->getString("GlobalY"); -char* _PREHASH_CopyRotates = LLMessageStringTable::getInstance()->getString("CopyRotates"); -char* _PREHASH_KickUserAck = LLMessageStringTable::getInstance()->getString("KickUserAck"); -char* _PREHASH_TopPick = LLMessageStringTable::getInstance()->getString("TopPick"); //legacy var need to be deleted -angela -char* _PREHASH_SessionID = LLMessageStringTable::getInstance()->getString("SessionID"); -char* _PREHASH_GlobalZ = LLMessageStringTable::getInstance()->getString("GlobalZ"); -char* _PREHASH_DeclineFriendship = LLMessageStringTable::getInstance()->getString("DeclineFriendship"); -char* _PREHASH_FormFriendship = LLMessageStringTable::getInstance()->getString("FormFriendship"); -char* _PREHASH_TerminateFriendship = LLMessageStringTable::getInstance()->getString("TerminateFriendship"); -char* _PREHASH_TaskData = LLMessageStringTable::getInstance()->getString("TaskData"); -char* _PREHASH_SimWideMaxPrims = LLMessageStringTable::getInstance()->getString("SimWideMaxPrims"); -char* _PREHASH_TotalPrims = LLMessageStringTable::getInstance()->getString("TotalPrims"); -char* _PREHASH_ProfileBegin = LLMessageStringTable::getInstance()->getString("ProfileBegin"); -char* _PREHASH_Request = LLMessageStringTable::getInstance()->getString("Request"); -char* _PREHASH_GroupAccountDetailsRequest = LLMessageStringTable::getInstance()->getString("GroupAccountDetailsRequest"); -char* _PREHASH_GroupActiveProposalsRequest = LLMessageStringTable::getInstance()->getString("GroupActiveProposalsRequest"); -char* _PREHASH_StringValue = LLMessageStringTable::getInstance()->getString("StringValue"); -char* _PREHASH_Version = LLMessageStringTable::getInstance()->getString("Version"); -char* _PREHASH_OtherCount = LLMessageStringTable::getInstance()->getString("OtherCount"); -char* _PREHASH_MemberCount = LLMessageStringTable::getInstance()->getString("MemberCount"); -char* _PREHASH_ChatData = LLMessageStringTable::getInstance()->getString("ChatData"); -char* _PREHASH_IsGroupOwned = LLMessageStringTable::getInstance()->getString("IsGroupOwned"); -char* _PREHASH_EnergyEfficiency = LLMessageStringTable::getInstance()->getString("EnergyEfficiency"); -char* _PREHASH_PickInfoUpdate = LLMessageStringTable::getInstance()->getString("PickInfoUpdate"); -char* _PREHASH_PickDelete = LLMessageStringTable::getInstance()->getString("PickDelete"); -char* _PREHASH_ScriptReset = LLMessageStringTable::getInstance()->getString("ScriptReset"); -char* _PREHASH_Requester = LLMessageStringTable::getInstance()->getString("Requester"); -char* _PREHASH_ForSale = LLMessageStringTable::getInstance()->getString("ForSale"); -char* _PREHASH_NearestLandingRegionReply = LLMessageStringTable::getInstance()->getString("NearestLandingRegionReply"); -char* _PREHASH_ParcelID = LLMessageStringTable::getInstance()->getString("ParcelID"); -char* _PREHASH_Godlike = LLMessageStringTable::getInstance()->getString("Godlike"); -char* _PREHASH_TotalDebits = LLMessageStringTable::getInstance()->getString("TotalDebits"); -char* _PREHASH_Direction = LLMessageStringTable::getInstance()->getString("Direction"); -char* _PREHASH_HealthData = LLMessageStringTable::getInstance()->getString("HealthData"); -char* _PREHASH_LeftAxis = LLMessageStringTable::getInstance()->getString("LeftAxis"); -char* _PREHASH_LocationBlock = LLMessageStringTable::getInstance()->getString("LocationBlock"); -char* _PREHASH_ObjectImage = LLMessageStringTable::getInstance()->getString("ObjectImage"); -char* _PREHASH_TerrainStartHeight00 = LLMessageStringTable::getInstance()->getString("TerrainStartHeight00"); -char* _PREHASH_TerrainStartHeight01 = LLMessageStringTable::getInstance()->getString("TerrainStartHeight01"); -char* _PREHASH_TerrainStartHeight10 = LLMessageStringTable::getInstance()->getString("TerrainStartHeight10"); -char* _PREHASH_TerrainStartHeight11 = LLMessageStringTable::getInstance()->getString("TerrainStartHeight11"); -char* _PREHASH_WaterHeight = LLMessageStringTable::getInstance()->getString("WaterHeight"); -char* _PREHASH_FetchInventoryReply = LLMessageStringTable::getInstance()->getString("FetchInventoryReply"); -char* _PREHASH_GroupAccountSummaryReply = LLMessageStringTable::getInstance()->getString("GroupAccountSummaryReply"); -char* _PREHASH_AttachedSound = LLMessageStringTable::getInstance()->getString("AttachedSound"); -char* _PREHASH_ParamInUse = LLMessageStringTable::getInstance()->getString("ParamInUse"); -char* _PREHASH_GodKickUser = LLMessageStringTable::getInstance()->getString("GodKickUser"); -char* _PREHASH_PickName = LLMessageStringTable::getInstance()->getString("PickName"); -char* _PREHASH_TaskName = LLMessageStringTable::getInstance()->getString("TaskName"); -char* _PREHASH_ObjectCount = LLMessageStringTable::getInstance()->getString("ObjectCount"); -char* _PREHASH_RegionPresenceRequestByHandle = LLMessageStringTable::getInstance()->getString("RegionPresenceRequestByHandle"); -char* _PREHASH_RezSingleAttachmentFromInv = LLMessageStringTable::getInstance()->getString("RezSingleAttachmentFromInv"); -char* _PREHASH_ChildAgentUpdate = LLMessageStringTable::getInstance()->getString("ChildAgentUpdate"); -char* _PREHASH_IsOwnerGroup = LLMessageStringTable::getInstance()->getString("IsOwnerGroup"); -char* _PREHASH_AgentHeightWidth = LLMessageStringTable::getInstance()->getString("AgentHeightWidth"); -char* _PREHASH_VerticalAngle = LLMessageStringTable::getInstance()->getString("VerticalAngle"); -char* _PREHASH_WearableType = LLMessageStringTable::getInstance()->getString("WearableType"); -char* _PREHASH_AggregatePermNextOwner = LLMessageStringTable::getInstance()->getString("AggregatePermNextOwner"); -char* _PREHASH_ShowInList = LLMessageStringTable::getInstance()->getString("ShowInList"); -char* _PREHASH_UpdateParcel = LLMessageStringTable::getInstance()->getString("UpdateParcel"); -char* _PREHASH_SetAlwaysRun = LLMessageStringTable::getInstance()->getString("SetAlwaysRun"); -char* _PREHASH_NVPair = LLMessageStringTable::getInstance()->getString("NVPair"); -char* _PREHASH_SearchType = LLMessageStringTable::getInstance()->getString("SearchType"); -char* _PREHASH_ObjectSpinStart = LLMessageStringTable::getInstance()->getString("ObjectSpinStart"); -char* _PREHASH_UseEstateSun = LLMessageStringTable::getInstance()->getString("UseEstateSun"); -char* _PREHASH_RegionID = LLMessageStringTable::getInstance()->getString("RegionID"); -char* _PREHASH_AbuseRegionID = LLMessageStringTable::getInstance()->getString("AbuseRegionID"); -char* _PREHASH_Creator = LLMessageStringTable::getInstance()->getString("Creator"); -char* _PREHASH_ProposalText = LLMessageStringTable::getInstance()->getString("ProposalText"); -char* _PREHASH_DirEventsReply = LLMessageStringTable::getInstance()->getString("DirEventsReply"); -char* _PREHASH_EventInfoReply = LLMessageStringTable::getInstance()->getString("EventInfoReply"); -char* _PREHASH_UserInfoReply = LLMessageStringTable::getInstance()->getString("UserInfoReply"); -char* _PREHASH_PathRadiusOffset = LLMessageStringTable::getInstance()->getString("PathRadiusOffset"); -char* _PREHASH_TextureData = LLMessageStringTable::getInstance()->getString("TextureData"); -char* _PREHASH_ChatPass = LLMessageStringTable::getInstance()->getString("ChatPass"); -char* _PREHASH_TargetID = LLMessageStringTable::getInstance()->getString("TargetID"); -char* _PREHASH_DefaultPayPrice = LLMessageStringTable::getInstance()->getString("DefaultPayPrice"); -char* _PREHASH_UserLocation = LLMessageStringTable::getInstance()->getString("UserLocation"); -char* _PREHASH_MaxPrims = LLMessageStringTable::getInstance()->getString("MaxPrims"); -char* _PREHASH_LandmarkID = LLMessageStringTable::getInstance()->getString("LandmarkID"); -char* _PREHASH_InitiateDownload = LLMessageStringTable::getInstance()->getString("InitiateDownload"); -char* _PREHASH_Name = LLMessageStringTable::getInstance()->getString("Name"); -char* _PREHASH_OtherCleanTime = LLMessageStringTable::getInstance()->getString("OtherCleanTime"); -char* _PREHASH_ParcelSetOtherCleanTime = LLMessageStringTable::getInstance()->getString("ParcelSetOtherCleanTime"); -char* _PREHASH_TeleportPriceExponent = LLMessageStringTable::getInstance()->getString("TeleportPriceExponent"); -char* _PREHASH_Gain = LLMessageStringTable::getInstance()->getString("Gain"); -char* _PREHASH_PacketAck = LLMessageStringTable::getInstance()->getString("PacketAck"); -char* _PREHASH_PathSkew = LLMessageStringTable::getInstance()->getString("PathSkew"); -char* _PREHASH_SimulatorShutdownRequest = LLMessageStringTable::getInstance()->getString("SimulatorShutdownRequest"); -char* _PREHASH_NearestLandingRegionRequest = LLMessageStringTable::getInstance()->getString("NearestLandingRegionRequest"); -char* _PREHASH_OtherID = LLMessageStringTable::getInstance()->getString("OtherID"); -char* _PREHASH_MemberID = LLMessageStringTable::getInstance()->getString("MemberID"); -char* _PREHASH_MapLayerRequest = LLMessageStringTable::getInstance()->getString("MapLayerRequest"); -char* _PREHASH_ObjectScale = LLMessageStringTable::getInstance()->getString("ObjectScale"); -char* _PREHASH_TargetIP = LLMessageStringTable::getInstance()->getString("TargetIP"); -char* _PREHASH_Redo = LLMessageStringTable::getInstance()->getString("Redo"); -char* _PREHASH_MoneyBalance = LLMessageStringTable::getInstance()->getString("MoneyBalance"); -char* _PREHASH_TrackAgent = LLMessageStringTable::getInstance()->getString("TrackAgent"); -char* _PREHASH_MaxX = LLMessageStringTable::getInstance()->getString("MaxX"); -char* _PREHASH_Data = LLMessageStringTable::getInstance()->getString("Data"); -char* _PREHASH_MaxY = LLMessageStringTable::getInstance()->getString("MaxY"); -char* _PREHASH_TextureAnim = LLMessageStringTable::getInstance()->getString("TextureAnim"); -char* _PREHASH_ReturnIDs = LLMessageStringTable::getInstance()->getString("ReturnIDs"); -char* _PREHASH_Date = LLMessageStringTable::getInstance()->getString("Date"); -char* _PREHASH_AgentWearablesUpdate = LLMessageStringTable::getInstance()->getString("AgentWearablesUpdate"); -char* _PREHASH_AgentDataUpdate = LLMessageStringTable::getInstance()->getString("AgentDataUpdate"); -char* _PREHASH_GroupDataUpdate = LLMessageStringTable::getInstance()->getString("GroupDataUpdate"); -char* _PREHASH_Hash = LLMessageStringTable::getInstance()->getString("Hash"); -char* _PREHASH_AgentGroupDataUpdate = LLMessageStringTable::getInstance()->getString("AgentGroupDataUpdate"); -char* _PREHASH_Left = LLMessageStringTable::getInstance()->getString("Left"); -char* _PREHASH_Mask = LLMessageStringTable::getInstance()->getString("Mask"); -char* _PREHASH_ForceMouselook = LLMessageStringTable::getInstance()->getString("ForceMouselook"); -char* _PREHASH_Success = LLMessageStringTable::getInstance()->getString("Success"); -char* _PREHASH_ObjectGroup = LLMessageStringTable::getInstance()->getString("ObjectGroup"); -char* _PREHASH_SunHour = LLMessageStringTable::getInstance()->getString("SunHour"); -char* _PREHASH_MinX = LLMessageStringTable::getInstance()->getString("MinX"); -char* _PREHASH_ScriptSensorReply = LLMessageStringTable::getInstance()->getString("ScriptSensorReply"); -char* _PREHASH_MinY = LLMessageStringTable::getInstance()->getString("MinY"); -char* _PREHASH_Command = LLMessageStringTable::getInstance()->getString("Command"); -char* _PREHASH_Desc = LLMessageStringTable::getInstance()->getString("Desc"); -char* _PREHASH_AttachmentNeedsSave = LLMessageStringTable::getInstance()->getString("AttachmentNeedsSave"); -char* _PREHASH_HistoryItemData = LLMessageStringTable::getInstance()->getString("HistoryItemData"); -char* _PREHASH_AgentCachedTexture = LLMessageStringTable::getInstance()->getString("AgentCachedTexture"); -char* _PREHASH_Subject = LLMessageStringTable::getInstance()->getString("Subject"); -char* _PREHASH_East = LLMessageStringTable::getInstance()->getString("East"); -char* _PREHASH_QueryReplies = LLMessageStringTable::getInstance()->getString("QueryReplies"); -char* _PREHASH_ObjectCategory = LLMessageStringTable::getInstance()->getString("ObjectCategory"); -char* _PREHASH_Time = LLMessageStringTable::getInstance()->getString("Time"); -char* _PREHASH_CreateLandmarkForEvent = LLMessageStringTable::getInstance()->getString("CreateLandmarkForEvent"); -char* _PREHASH_ParentID = LLMessageStringTable::getInstance()->getString("ParentID"); -char* _PREHASH_Ping = LLMessageStringTable::getInstance()->getString("Ping"); -char* _PREHASH_Perp = LLMessageStringTable::getInstance()->getString("Perp"); -char* _PREHASH_Code = LLMessageStringTable::getInstance()->getString("Code"); -char* _PREHASH_InvType = LLMessageStringTable::getInstance()->getString("InvType"); -char* _PREHASH_AgentFOV = LLMessageStringTable::getInstance()->getString("AgentFOV"); -char* _PREHASH_Audible = LLMessageStringTable::getInstance()->getString("Audible"); -char* _PREHASH_AuctionData = LLMessageStringTable::getInstance()->getString("AuctionData"); -char* _PREHASH_IDBlock = LLMessageStringTable::getInstance()->getString("IDBlock"); -char* _PREHASH_West = LLMessageStringTable::getInstance()->getString("West"); -char* _PREHASH_Undo = LLMessageStringTable::getInstance()->getString("Undo"); -char* _PREHASH_TotalNumItems = LLMessageStringTable::getInstance()->getString("TotalNumItems"); -char* _PREHASH_Info = LLMessageStringTable::getInstance()->getString("Info"); -char* _PREHASH_Area = LLMessageStringTable::getInstance()->getString("Area"); -char* _PREHASH_SimCrashed = LLMessageStringTable::getInstance()->getString("SimCrashed"); -char* _PREHASH_Text = LLMessageStringTable::getInstance()->getString("Text"); -char* _PREHASH_PriceGroupCreate = LLMessageStringTable::getInstance()->getString("PriceGroupCreate"); -char* _PREHASH_ObjectShape = LLMessageStringTable::getInstance()->getString("ObjectShape"); -char* _PREHASH_GroupRoleDataReply = LLMessageStringTable::getInstance()->getString("GroupRoleDataReply"); -char* _PREHASH_MuteCRC = LLMessageStringTable::getInstance()->getString("MuteCRC"); -char* _PREHASH_Size = LLMessageStringTable::getInstance()->getString("Size"); -char* _PREHASH_FromAddress = LLMessageStringTable::getInstance()->getString("FromAddress"); -char* _PREHASH_Body = LLMessageStringTable::getInstance()->getString("Body"); -char* _PREHASH_FileData = LLMessageStringTable::getInstance()->getString("FileData"); -char* _PREHASH_List = LLMessageStringTable::getInstance()->getString("List"); -char* _PREHASH_KickUser = LLMessageStringTable::getInstance()->getString("KickUser"); -char* _PREHASH_OtherPrims = LLMessageStringTable::getInstance()->getString("OtherPrims"); -char* _PREHASH_RunTime = LLMessageStringTable::getInstance()->getString("RunTime"); -char* _PREHASH_GrantUserRights = LLMessageStringTable::getInstance()->getString("GrantUserRights"); -char* _PREHASH_RpcScriptRequestInboundForward = LLMessageStringTable::getInstance()->getString("RpcScriptRequestInboundForward"); -char* _PREHASH_More = LLMessageStringTable::getInstance()->getString("More"); -char* _PREHASH_Majority = LLMessageStringTable::getInstance()->getString("Majority"); -char* _PREHASH_MetersTraveled = LLMessageStringTable::getInstance()->getString("MetersTraveled"); -char* _PREHASH_Stat = LLMessageStringTable::getInstance()->getString("Stat"); -char* _PREHASH_SoundID = LLMessageStringTable::getInstance()->getString("SoundID"); -char* _PREHASH_Item = LLMessageStringTable::getInstance()->getString("Item"); -char* _PREHASH_User = LLMessageStringTable::getInstance()->getString("User"); -char* _PREHASH_Prey = LLMessageStringTable::getInstance()->getString("Prey"); -char* _PREHASH_RayStart = LLMessageStringTable::getInstance()->getString("RayStart"); -char* _PREHASH_UsecSinceStart = LLMessageStringTable::getInstance()->getString("UsecSinceStart"); -char* _PREHASH_ParcelData = LLMessageStringTable::getInstance()->getString("ParcelData"); -char* _PREHASH_CameraUpAxis = LLMessageStringTable::getInstance()->getString("CameraUpAxis"); -char* _PREHASH_ScriptDialog = LLMessageStringTable::getInstance()->getString("ScriptDialog"); -char* _PREHASH_MasterParcelData = LLMessageStringTable::getInstance()->getString("MasterParcelData"); -char* _PREHASH_Invalid = LLMessageStringTable::getInstance()->getString("Invalid"); -char* _PREHASH_ProfileCurve = LLMessageStringTable::getInstance()->getString("ProfileCurve"); -char* _PREHASH_ParcelAccessListUpdate = LLMessageStringTable::getInstance()->getString("ParcelAccessListUpdate"); -char* _PREHASH_MuteListUpdate = LLMessageStringTable::getInstance()->getString("MuteListUpdate"); -char* _PREHASH_SendPacket = LLMessageStringTable::getInstance()->getString("SendPacket"); -char* _PREHASH_SendXferPacket = LLMessageStringTable::getInstance()->getString("SendXferPacket"); -char* _PREHASH_RegionDenyIdentified = LLMessageStringTable::getInstance()->getString("RegionDenyIdentified"); -char* _PREHASH_NotecardItemID = LLMessageStringTable::getInstance()->getString("NotecardItemID"); -char* _PREHASH_LastName = LLMessageStringTable::getInstance()->getString("LastName"); -char* _PREHASH_From = LLMessageStringTable::getInstance()->getString("From"); -char* _PREHASH_RoleChange = LLMessageStringTable::getInstance()->getString("RoleChange"); -char* _PREHASH_Port = LLMessageStringTable::getInstance()->getString("Port"); -char* _PREHASH_MemberTitle = LLMessageStringTable::getInstance()->getString("MemberTitle"); -char* _PREHASH_LogParcelChanges = LLMessageStringTable::getInstance()->getString("LogParcelChanges"); -char* _PREHASH_AgentCachedTextureResponse = LLMessageStringTable::getInstance()->getString("AgentCachedTextureResponse"); -char* _PREHASH_DeRezObject = LLMessageStringTable::getInstance()->getString("DeRezObject"); -char* _PREHASH_IsTemporary = LLMessageStringTable::getInstance()->getString("IsTemporary"); -char* _PREHASH_InsigniaID = LLMessageStringTable::getInstance()->getString("InsigniaID"); -char* _PREHASH_CheckFlags = LLMessageStringTable::getInstance()->getString("CheckFlags"); -char* _PREHASH_EventID = LLMessageStringTable::getInstance()->getString("EventID"); -char* _PREHASH_Selected = LLMessageStringTable::getInstance()->getString("Selected"); -char* _PREHASH_FromAgentId = LLMessageStringTable::getInstance()->getString("FromAgentId"); -char* _PREHASH_Type = LLMessageStringTable::getInstance()->getString("Type"); -char* _PREHASH_ChatType = LLMessageStringTable::getInstance()->getString("ChatType"); -char* _PREHASH_ReportData = LLMessageStringTable::getInstance()->getString("ReportData"); -char* _PREHASH_RequestBlock = LLMessageStringTable::getInstance()->getString("RequestBlock"); -char* _PREHASH_GrantData = LLMessageStringTable::getInstance()->getString("GrantData"); -char* _PREHASH_DetachAttachmentIntoInv = LLMessageStringTable::getInstance()->getString("DetachAttachmentIntoInv"); -char* _PREHASH_ParcelDisableObjects = LLMessageStringTable::getInstance()->getString("ParcelDisableObjects"); -char* _PREHASH_Sections = LLMessageStringTable::getInstance()->getString("Sections"); -char* _PREHASH_GodLevel = LLMessageStringTable::getInstance()->getString("GodLevel"); -char* _PREHASH_PayPriceReply = LLMessageStringTable::getInstance()->getString("PayPriceReply"); -char* _PREHASH_QueryID = LLMessageStringTable::getInstance()->getString("QueryID"); -char* _PREHASH_CameraEyeOffset = LLMessageStringTable::getInstance()->getString("CameraEyeOffset"); -char* _PREHASH_AgentPosition = LLMessageStringTable::getInstance()->getString("AgentPosition"); -char* _PREHASH_GrabPosition = LLMessageStringTable::getInstance()->getString("GrabPosition"); -char* _PREHASH_OnlineNotification = LLMessageStringTable::getInstance()->getString("OnlineNotification"); -char* _PREHASH_OfflineNotification = LLMessageStringTable::getInstance()->getString("OfflineNotification"); -char* _PREHASH_SendPostcard = LLMessageStringTable::getInstance()->getString("SendPostcard"); -char* _PREHASH_RequestFlags = LLMessageStringTable::getInstance()->getString("RequestFlags"); -char* _PREHASH_GroupAccountSummaryRequest = LLMessageStringTable::getInstance()->getString("GroupAccountSummaryRequest"); -char* _PREHASH_GroupVoteHistoryRequest = LLMessageStringTable::getInstance()->getString("GroupVoteHistoryRequest"); -char* _PREHASH_ParamValue = LLMessageStringTable::getInstance()->getString("ParamValue"); -char* _PREHASH_MaxAgents = LLMessageStringTable::getInstance()->getString("MaxAgents"); -char* _PREHASH_CreateNewOutfitAttachments = LLMessageStringTable::getInstance()->getString("CreateNewOutfitAttachments"); -char* _PREHASH_RegionHandle = LLMessageStringTable::getInstance()->getString("RegionHandle"); -char* _PREHASH_TeleportProgress = LLMessageStringTable::getInstance()->getString("TeleportProgress"); -char* _PREHASH_AgentQuitCopy = LLMessageStringTable::getInstance()->getString("AgentQuitCopy"); -char* _PREHASH_AvatarInterestsUpdate = LLMessageStringTable::getInstance()->getString("AvatarInterestsUpdate"); -char* _PREHASH_GroupNoticeID = LLMessageStringTable::getInstance()->getString("GroupNoticeID"); -char* _PREHASH_ParcelName = LLMessageStringTable::getInstance()->getString("ParcelName"); -char* _PREHASH_PriceObjectRent = LLMessageStringTable::getInstance()->getString("PriceObjectRent"); -char* _PREHASH_OfferCallingCard = LLMessageStringTable::getInstance()->getString("OfferCallingCard"); -char* _PREHASH_AcceptCallingCard = LLMessageStringTable::getInstance()->getString("AcceptCallingCard"); -char* _PREHASH_DeclineCallingCard = LLMessageStringTable::getInstance()->getString("DeclineCallingCard"); -char* _PREHASH_AgentAccess = LLMessageStringTable::getInstance()->getString("AgentAccess"); -char* _PREHASH_AgentLegacyAccess = LLMessageStringTable::getInstance()->getString("AgentLegacyAccess"); -char* _PREHASH_AgentMaxAccess = LLMessageStringTable::getInstance()->getString("AgentMaxAccess"); -char* _PREHASH_DataHomeLocationReply = LLMessageStringTable::getInstance()->getString("DataHomeLocationReply"); -char* _PREHASH_EventLocationReply = LLMessageStringTable::getInstance()->getString("EventLocationReply"); -char* _PREHASH_TerseDateID = LLMessageStringTable::getInstance()->getString("TerseDateID"); -char* _PREHASH_ObjectOwner = LLMessageStringTable::getInstance()->getString("ObjectOwner"); -char* _PREHASH_AssetID = LLMessageStringTable::getInstance()->getString("AssetID"); -char* _PREHASH_AlertMessage = LLMessageStringTable::getInstance()->getString("AlertMessage"); -char* _PREHASH_AgentAlertMessage = LLMessageStringTable::getInstance()->getString("AgentAlertMessage"); -char* _PREHASH_EstateOwnerMessage = LLMessageStringTable::getInstance()->getString("EstateOwnerMessage"); -char* _PREHASH_ParcelMediaCommandMessage = LLMessageStringTable::getInstance()->getString("ParcelMediaCommandMessage"); -char* _PREHASH_Auction = LLMessageStringTable::getInstance()->getString("Auction"); -char* _PREHASH_Category = LLMessageStringTable::getInstance()->getString("Category"); -char* _PREHASH_FilePath = LLMessageStringTable::getInstance()->getString("FilePath"); -char* _PREHASH_ItemFlags = LLMessageStringTable::getInstance()->getString("ItemFlags"); -char* _PREHASH_Invoice = LLMessageStringTable::getInstance()->getString("Invoice"); -char* _PREHASH_IntervalDays = LLMessageStringTable::getInstance()->getString("IntervalDays"); -char* _PREHASH_PathScaleX = LLMessageStringTable::getInstance()->getString("PathScaleX"); -char* _PREHASH_FromTaskID = LLMessageStringTable::getInstance()->getString("FromTaskID"); -char* _PREHASH_PathScaleY = LLMessageStringTable::getInstance()->getString("PathScaleY"); -char* _PREHASH_TimeInfo = LLMessageStringTable::getInstance()->getString("TimeInfo"); -char* _PREHASH_PublicCount = LLMessageStringTable::getInstance()->getString("PublicCount"); -char* _PREHASH_ParcelJoin = LLMessageStringTable::getInstance()->getString("ParcelJoin"); -char* _PREHASH_GroupRolesCount = LLMessageStringTable::getInstance()->getString("GroupRolesCount"); -char* _PREHASH_SimulatorBlock = LLMessageStringTable::getInstance()->getString("SimulatorBlock"); -char* _PREHASH_GroupID = LLMessageStringTable::getInstance()->getString("GroupID"); -char* _PREHASH_AgentVel = LLMessageStringTable::getInstance()->getString("AgentVel"); -char* _PREHASH_RequestImage = LLMessageStringTable::getInstance()->getString("RequestImage"); -char* _PREHASH_NetStats = LLMessageStringTable::getInstance()->getString("NetStats"); -char* _PREHASH_AgentPos = LLMessageStringTable::getInstance()->getString("AgentPos"); -char* _PREHASH_AgentSit = LLMessageStringTable::getInstance()->getString("AgentSit"); -char* _PREHASH_Material = LLMessageStringTable::getInstance()->getString("Material"); -char* _PREHASH_ObjectDeGrab = LLMessageStringTable::getInstance()->getString("ObjectDeGrab"); -char* _PREHASH_VelocityInterpolateOff = LLMessageStringTable::getInstance()->getString("VelocityInterpolateOff"); -char* _PREHASH_AuthorizedBuyerID = LLMessageStringTable::getInstance()->getString("AuthorizedBuyerID"); -char* _PREHASH_AvatarPropertiesReply = LLMessageStringTable::getInstance()->getString("AvatarPropertiesReply"); -char* _PREHASH_GroupProfileReply = LLMessageStringTable::getInstance()->getString("GroupProfileReply"); -char* _PREHASH_SimOwner = LLMessageStringTable::getInstance()->getString("SimOwner"); -char* _PREHASH_SalePrice = LLMessageStringTable::getInstance()->getString("SalePrice"); -char* _PREHASH_Animation = LLMessageStringTable::getInstance()->getString("Animation"); -char* _PREHASH_OwnerID = LLMessageStringTable::getInstance()->getString("OwnerID"); -char* _PREHASH_NearestLandingRegionUpdated = LLMessageStringTable::getInstance()->getString("NearestLandingRegionUpdated"); -char* _PREHASH_PassToAgent = LLMessageStringTable::getInstance()->getString("PassToAgent"); -char* _PREHASH_PreyAgent = LLMessageStringTable::getInstance()->getString("PreyAgent"); -char* _PREHASH_SimStats = LLMessageStringTable::getInstance()->getString("SimStats"); -char* _PREHASH_LogoutReply = LLMessageStringTable::getInstance()->getString("LogoutReply"); -char* _PREHASH_FeatureDisabled = LLMessageStringTable::getInstance()->getString("FeatureDisabled"); -char* _PREHASH_PhysicalAvatarEventList = LLMessageStringTable::getInstance()->getString("PhysicalAvatarEventList"); -char* _PREHASH_ObjectLocalID = LLMessageStringTable::getInstance()->getString("ObjectLocalID"); -char* _PREHASH_Dropped = LLMessageStringTable::getInstance()->getString("Dropped"); -char* _PREHASH_WebProfilesDisabled = LLMessageStringTable::getInstance()->getString("WebProfilesDisabled"); -char* _PREHASH_Destination = LLMessageStringTable::getInstance()->getString("Destination"); -char* _PREHASH_MasterID = LLMessageStringTable::getInstance()->getString("MasterID"); -char* _PREHASH_TransferData = LLMessageStringTable::getInstance()->getString("TransferData"); -char* _PREHASH_WantToMask = LLMessageStringTable::getInstance()->getString("WantToMask"); -char* _PREHASH_ParcelSelectObjects = LLMessageStringTable::getInstance()->getString("ParcelSelectObjects"); -char* _PREHASH_ExtraParams = LLMessageStringTable::getInstance()->getString("ExtraParams"); -char* _PREHASH_CreatorID = LLMessageStringTable::getInstance()->getString("CreatorID"); -char* _PREHASH_Summary = LLMessageStringTable::getInstance()->getString("Summary"); -char* _PREHASH_BuyObjectInventory = LLMessageStringTable::getInstance()->getString("BuyObjectInventory"); -char* _PREHASH_FetchInventory = LLMessageStringTable::getInstance()->getString("FetchInventory"); -char* _PREHASH_InventoryID = LLMessageStringTable::getInstance()->getString("InventoryID"); -char* _PREHASH_PacketNumber = LLMessageStringTable::getInstance()->getString("PacketNumber"); -char* _PREHASH_SetFollowCamProperties = LLMessageStringTable::getInstance()->getString("SetFollowCamProperties"); -char* _PREHASH_ClearFollowCamProperties = LLMessageStringTable::getInstance()->getString("ClearFollowCamProperties"); -char* _PREHASH_SequenceID = LLMessageStringTable::getInstance()->getString("SequenceID"); -char* _PREHASH_DataServerLogout = LLMessageStringTable::getInstance()->getString("DataServerLogout"); -char* _PREHASH_NameValue = LLMessageStringTable::getInstance()->getString("NameValue"); -char* _PREHASH_PathShearX = LLMessageStringTable::getInstance()->getString("PathShearX"); -char* _PREHASH_PathShearY = LLMessageStringTable::getInstance()->getString("PathShearY"); -char* _PREHASH_Velocity = LLMessageStringTable::getInstance()->getString("Velocity"); -char* _PREHASH_SecPerYear = LLMessageStringTable::getInstance()->getString("SecPerYear"); -char* _PREHASH_FirstName = LLMessageStringTable::getInstance()->getString("FirstName"); -char* _PREHASH_AttachedSoundGainChange = LLMessageStringTable::getInstance()->getString("AttachedSoundGainChange"); -char* _PREHASH_LocationID = LLMessageStringTable::getInstance()->getString("LocationID"); -char* _PREHASH_Running = LLMessageStringTable::getInstance()->getString("Running"); -char* _PREHASH_AgentThrottle = LLMessageStringTable::getInstance()->getString("AgentThrottle"); -char* _PREHASH_NeighborList = LLMessageStringTable::getInstance()->getString("NeighborList"); -char* _PREHASH_PathTaperX = LLMessageStringTable::getInstance()->getString("PathTaperX"); -char* _PREHASH_PathTaperY = LLMessageStringTable::getInstance()->getString("PathTaperY"); -char* _PREHASH_AgentRelated = LLMessageStringTable::getInstance()->getString("AgentRelated"); -char* _PREHASH_GranterBlock = LLMessageStringTable::getInstance()->getString("GranterBlock"); -char* _PREHASH_UseCachedMuteList = LLMessageStringTable::getInstance()->getString("UseCachedMuteList"); -char* _PREHASH_FailStats = LLMessageStringTable::getInstance()->getString("FailStats"); -char* _PREHASH_Tempfile = LLMessageStringTable::getInstance()->getString("Tempfile"); -char* _PREHASH_BuyerID = LLMessageStringTable::getInstance()->getString("BuyerID"); -char* _PREHASH_DirPeopleReply = LLMessageStringTable::getInstance()->getString("DirPeopleReply"); -char* _PREHASH_TransferInfo = LLMessageStringTable::getInstance()->getString("TransferInfo"); -char* _PREHASH_AvatarPickerRequestBackend = LLMessageStringTable::getInstance()->getString("AvatarPickerRequestBackend"); -char* _PREHASH_AvatarPropertiesRequestBackend = LLMessageStringTable::getInstance()->getString("AvatarPropertiesRequestBackend"); -char* _PREHASH_UpdateData = LLMessageStringTable::getInstance()->getString("UpdateData"); -char* _PREHASH_SimFPS = LLMessageStringTable::getInstance()->getString("SimFPS"); -char* _PREHASH_ReporterID = LLMessageStringTable::getInstance()->getString("ReporterID"); -char* _PREHASH_ButtonLabel = LLMessageStringTable::getInstance()->getString("ButtonLabel"); -char* _PREHASH_GranterID = LLMessageStringTable::getInstance()->getString("GranterID"); -char* _PREHASH_WantToText = LLMessageStringTable::getInstance()->getString("WantToText"); -char* _PREHASH_ReportType = LLMessageStringTable::getInstance()->getString("ReportType"); -char* _PREHASH_SimulatorReady = LLMessageStringTable::getInstance()->getString("SimulatorReady"); -char* _PREHASH_DataBlock = LLMessageStringTable::getInstance()->getString("DataBlock"); -char* _PREHASH_AnimationSourceList = LLMessageStringTable::getInstance()->getString("AnimationSourceList"); -char* _PREHASH_SubscribeLoad = LLMessageStringTable::getInstance()->getString("SubscribeLoad"); -char* _PREHASH_UnsubscribeLoad = LLMessageStringTable::getInstance()->getString("UnsubscribeLoad"); -char* _PREHASH_Packet = LLMessageStringTable::getInstance()->getString("Packet"); -char* _PREHASH_UndoLand = LLMessageStringTable::getInstance()->getString("UndoLand"); -char* _PREHASH_SimAccess = LLMessageStringTable::getInstance()->getString("SimAccess"); -char* _PREHASH_AbuserID = LLMessageStringTable::getInstance()->getString("AbuserID"); -char* _PREHASH_MembershipFee = LLMessageStringTable::getInstance()->getString("MembershipFee"); -char* _PREHASH_InviteGroupResponse = LLMessageStringTable::getInstance()->getString("InviteGroupResponse"); -char* _PREHASH_CreateInventoryFolder = LLMessageStringTable::getInstance()->getString("CreateInventoryFolder"); -char* _PREHASH_UpdateInventoryFolder = LLMessageStringTable::getInstance()->getString("UpdateInventoryFolder"); -char* _PREHASH_MoveInventoryFolder = LLMessageStringTable::getInstance()->getString("MoveInventoryFolder"); -char* _PREHASH_RemoveInventoryFolder = LLMessageStringTable::getInstance()->getString("RemoveInventoryFolder"); -char* _PREHASH_MoneyData = LLMessageStringTable::getInstance()->getString("MoneyData"); -char* _PREHASH_ObjectDeselect = LLMessageStringTable::getInstance()->getString("ObjectDeselect"); -char* _PREHASH_NewAssetID = LLMessageStringTable::getInstance()->getString("NewAssetID"); -char* _PREHASH_ObjectAdd = LLMessageStringTable::getInstance()->getString("ObjectAdd"); -char* _PREHASH_RayEndIsIntersection = LLMessageStringTable::getInstance()->getString("RayEndIsIntersection"); -char* _PREHASH_CompleteAuction = LLMessageStringTable::getInstance()->getString("CompleteAuction"); -char* _PREHASH_CircuitCode = LLMessageStringTable::getInstance()->getString("CircuitCode"); -char* _PREHASH_AgentMovementComplete = LLMessageStringTable::getInstance()->getString("AgentMovementComplete"); -char* _PREHASH_ViewerIP = LLMessageStringTable::getInstance()->getString("ViewerIP"); -char* _PREHASH_Header = LLMessageStringTable::getInstance()->getString("Header"); -char* _PREHASH_GestureFlags = LLMessageStringTable::getInstance()->getString("GestureFlags"); -char* _PREHASH_XferID = LLMessageStringTable::getInstance()->getString("XferID"); -char* _PREHASH_StatValue = LLMessageStringTable::getInstance()->getString("StatValue"); -char* _PREHASH_TaskID = LLMessageStringTable::getInstance()->getString("TaskID"); -char* _PREHASH_PickID = LLMessageStringTable::getInstance()->getString("PickID"); -char* _PREHASH_RayEnd = LLMessageStringTable::getInstance()->getString("RayEnd"); -char* _PREHASH_Throttles = LLMessageStringTable::getInstance()->getString("Throttles"); -char* _PREHASH_RebakeAvatarTextures = LLMessageStringTable::getInstance()->getString("RebakeAvatarTextures"); -char* _PREHASH_UpAxis = LLMessageStringTable::getInstance()->getString("UpAxis"); -char* _PREHASH_AgentTextures = LLMessageStringTable::getInstance()->getString("AgentTextures"); -char* _PREHASH_NotecardData = LLMessageStringTable::getInstance()->getString("NotecardData"); -char* _PREHASH_Radius = LLMessageStringTable::getInstance()->getString("Radius"); -char* _PREHASH_OffCircuit = LLMessageStringTable::getInstance()->getString("OffCircuit"); -char* _PREHASH_Access = LLMessageStringTable::getInstance()->getString("Access"); -char* _PREHASH_TitleRoleID = LLMessageStringTable::getInstance()->getString("TitleRoleID"); -char* _PREHASH_SquareMetersCredit = LLMessageStringTable::getInstance()->getString("SquareMetersCredit"); -char* _PREHASH_Filename = LLMessageStringTable::getInstance()->getString("Filename"); -char* _PREHASH_ClassifiedInfoRequest = LLMessageStringTable::getInstance()->getString("ClassifiedInfoRequest"); -char* _PREHASH_ParcelInfoRequest = LLMessageStringTable::getInstance()->getString("ParcelInfoRequest"); -char* _PREHASH_ParcelObjectOwnersRequest = LLMessageStringTable::getInstance()->getString("ParcelObjectOwnersRequest"); -char* _PREHASH_TeleportLandmarkRequest = LLMessageStringTable::getInstance()->getString("TeleportLandmarkRequest"); -char* _PREHASH_EventInfoRequest = LLMessageStringTable::getInstance()->getString("EventInfoRequest"); -char* _PREHASH_MoneyBalanceRequest = LLMessageStringTable::getInstance()->getString("MoneyBalanceRequest"); -char* _PREHASH_GroupMembersRequest = LLMessageStringTable::getInstance()->getString("GroupMembersRequest"); -char* _PREHASH_GroupRoleMembersRequest = LLMessageStringTable::getInstance()->getString("GroupRoleMembersRequest"); -char* _PREHASH_ChatFromSimulator = LLMessageStringTable::getInstance()->getString("ChatFromSimulator"); -char* _PREHASH_OldFolderID = LLMessageStringTable::getInstance()->getString("OldFolderID"); -char* _PREHASH_UserInfoRequest = LLMessageStringTable::getInstance()->getString("UserInfoRequest"); -char* _PREHASH_TextureID = LLMessageStringTable::getInstance()->getString("TextureID"); -char* _PREHASH_ProfileURL = LLMessageStringTable::getInstance()->getString("ProfileURL"); -char* _PREHASH_Handle = LLMessageStringTable::getInstance()->getString("Handle"); -char* _PREHASH_ButtonIndex = LLMessageStringTable::getInstance()->getString("ButtonIndex"); -char* _PREHASH_GetScriptRunning = LLMessageStringTable::getInstance()->getString("GetScriptRunning"); -char* _PREHASH_SetScriptRunning = LLMessageStringTable::getInstance()->getString("SetScriptRunning"); -char* _PREHASH_Health = LLMessageStringTable::getInstance()->getString("Health"); -char* _PREHASH_CircuitInfo = LLMessageStringTable::getInstance()->getString("CircuitInfo"); -char* _PREHASH_ObjectBuy = LLMessageStringTable::getInstance()->getString("ObjectBuy"); -char* _PREHASH_ProfileEnd = LLMessageStringTable::getInstance()->getString("ProfileEnd"); -char* _PREHASH_Effect = LLMessageStringTable::getInstance()->getString("Effect"); -char* _PREHASH_TestMessage = LLMessageStringTable::getInstance()->getString("TestMessage"); -char* _PREHASH_ScriptMailRegistration = LLMessageStringTable::getInstance()->getString("ScriptMailRegistration"); -char* _PREHASH_AgentSetAppearance = LLMessageStringTable::getInstance()->getString("AgentSetAppearance"); -char* _PREHASH_AvatarAppearance = LLMessageStringTable::getInstance()->getString("AvatarAppearance"); -char* _PREHASH_RegionData = LLMessageStringTable::getInstance()->getString("RegionData"); -char* _PREHASH_RequestingRegionData = LLMessageStringTable::getInstance()->getString("RequestingRegionData"); -char* _PREHASH_LandingRegionData = LLMessageStringTable::getInstance()->getString("LandingRegionData"); -char* _PREHASH_SitTransform = LLMessageStringTable::getInstance()->getString("SitTransform"); -char* _PREHASH_TerrainBase0 = LLMessageStringTable::getInstance()->getString("TerrainBase0"); -char* _PREHASH_SkillsMask = LLMessageStringTable::getInstance()->getString("SkillsMask"); -char* _PREHASH_AtAxis = LLMessageStringTable::getInstance()->getString("AtAxis"); -char* _PREHASH_TerrainBase1 = LLMessageStringTable::getInstance()->getString("TerrainBase1"); -char* _PREHASH_Reason = LLMessageStringTable::getInstance()->getString("Reason"); -char* _PREHASH_TerrainBase2 = LLMessageStringTable::getInstance()->getString("TerrainBase2"); -char* _PREHASH_TerrainBase3 = LLMessageStringTable::getInstance()->getString("TerrainBase3"); -char* _PREHASH_Params = LLMessageStringTable::getInstance()->getString("Params"); -char* _PREHASH_PingID = LLMessageStringTable::getInstance()->getString("PingID"); -char* _PREHASH_Change = LLMessageStringTable::getInstance()->getString("Change"); -char* _PREHASH_Height = LLMessageStringTable::getInstance()->getString("Height"); -char* _PREHASH_Region = LLMessageStringTable::getInstance()->getString("Region"); -char* _PREHASH_TelehubInfo = LLMessageStringTable::getInstance()->getString("TelehubInfo"); -char* _PREHASH_StateSave = LLMessageStringTable::getInstance()->getString("StateSave"); -char* _PREHASH_RoleData = LLMessageStringTable::getInstance()->getString("RoleData"); -char* _PREHASH_AgentAnimation = LLMessageStringTable::getInstance()->getString("AgentAnimation"); -char* _PREHASH_AvatarAnimation = LLMessageStringTable::getInstance()->getString("AvatarAnimation"); -char* _PREHASH_LogDwellTime = LLMessageStringTable::getInstance()->getString("LogDwellTime"); -char* _PREHASH_ParcelGodMarkAsContent = LLMessageStringTable::getInstance()->getString("ParcelGodMarkAsContent"); -char* _PREHASH_UsePhysics = LLMessageStringTable::getInstance()->getString("UsePhysics"); -char* _PREHASH_RegionDenyTransacted = LLMessageStringTable::getInstance()->getString("RegionDenyTransacted"); -char* _PREHASH_JointType = LLMessageStringTable::getInstance()->getString("JointType"); -char* _PREHASH_ObjectTaxEstimate = LLMessageStringTable::getInstance()->getString("ObjectTaxEstimate"); -char* _PREHASH_LightTaxEstimate = LLMessageStringTable::getInstance()->getString("LightTaxEstimate"); -char* _PREHASH_LandTaxEstimate = LLMessageStringTable::getInstance()->getString("LandTaxEstimate"); -char* _PREHASH_TeleportLandingStatusChanged = LLMessageStringTable::getInstance()->getString("TeleportLandingStatusChanged"); -char* _PREHASH_GroupTaxEstimate = LLMessageStringTable::getInstance()->getString("GroupTaxEstimate"); -char* _PREHASH_AvgViewerFPS = LLMessageStringTable::getInstance()->getString("AvgViewerFPS"); -char* _PREHASH_Buttons = LLMessageStringTable::getInstance()->getString("Buttons"); -char* _PREHASH_Sender = LLMessageStringTable::getInstance()->getString("Sender"); -char* _PREHASH_Dialog = LLMessageStringTable::getInstance()->getString("Dialog"); -char* _PREHASH_TargetData = LLMessageStringTable::getInstance()->getString("TargetData"); -char* _PREHASH_DestID = LLMessageStringTable::getInstance()->getString("DestID"); -char* _PREHASH_PricePublicObjectDelete = LLMessageStringTable::getInstance()->getString("PricePublicObjectDelete"); -char* _PREHASH_ObjectDelete = LLMessageStringTable::getInstance()->getString("ObjectDelete"); -char* _PREHASH_Delete = LLMessageStringTable::getInstance()->getString("Delete"); -char* _PREHASH_EventGodDelete = LLMessageStringTable::getInstance()->getString("EventGodDelete"); -char* _PREHASH_LastTaxDate = LLMessageStringTable::getInstance()->getString("LastTaxDate"); -char* _PREHASH_MapImageID = LLMessageStringTable::getInstance()->getString("MapImageID"); -char* _PREHASH_EndDateTime = LLMessageStringTable::getInstance()->getString("EndDateTime"); -char* _PREHASH_TerrainDetail0 = LLMessageStringTable::getInstance()->getString("TerrainDetail0"); -char* _PREHASH_TerrainDetail1 = LLMessageStringTable::getInstance()->getString("TerrainDetail1"); -char* _PREHASH_TerrainDetail2 = LLMessageStringTable::getInstance()->getString("TerrainDetail2"); -char* _PREHASH_TerrainDetail3 = LLMessageStringTable::getInstance()->getString("TerrainDetail3"); -char* _PREHASH_Offset = LLMessageStringTable::getInstance()->getString("Offset"); -char* _PREHASH_ObjectDelink = LLMessageStringTable::getInstance()->getString("ObjectDelink"); -char* _PREHASH_TargetObject = LLMessageStringTable::getInstance()->getString("TargetObject"); -char* _PREHASH_IsEstateManager = LLMessageStringTable::getInstance()->getString("IsEstateManager"); -char* _PREHASH_CancelAuction = LLMessageStringTable::getInstance()->getString("CancelAuction"); -char* _PREHASH_ObjectDetach = LLMessageStringTable::getInstance()->getString("ObjectDetach"); -char* _PREHASH_Compressed = LLMessageStringTable::getInstance()->getString("Compressed"); -char* _PREHASH_PathBegin = LLMessageStringTable::getInstance()->getString("PathBegin"); -char* _PREHASH_BypassRaycast = LLMessageStringTable::getInstance()->getString("BypassRaycast"); -char* _PREHASH_WinnerID = LLMessageStringTable::getInstance()->getString("WinnerID"); -char* _PREHASH_ChannelType = LLMessageStringTable::getInstance()->getString("ChannelType"); -char* _PREHASH_NonExemptMembers = LLMessageStringTable::getInstance()->getString("NonExemptMembers"); -char* _PREHASH_Agents = LLMessageStringTable::getInstance()->getString("Agents"); -char* _PREHASH_MemberData = LLMessageStringTable::getInstance()->getString("MemberData"); -char* _PREHASH_ToGroupID = LLMessageStringTable::getInstance()->getString("ToGroupID"); -char* _PREHASH_ImageNotInDatabase = LLMessageStringTable::getInstance()->getString("ImageNotInDatabase"); -char* _PREHASH_StartDate = LLMessageStringTable::getInstance()->getString("StartDate"); -char* _PREHASH_AnimID = LLMessageStringTable::getInstance()->getString("AnimID"); -char* _PREHASH_Serial = LLMessageStringTable::getInstance()->getString("Serial"); -char* _PREHASH_AbuseRegionName = LLMessageStringTable::getInstance()->getString("AbuseRegionName"); -char* _PREHASH_ModifyLand = LLMessageStringTable::getInstance()->getString("ModifyLand"); -char* _PREHASH_Digest = LLMessageStringTable::getInstance()->getString("Digest"); -char* _PREHASH_Victim = LLMessageStringTable::getInstance()->getString("Victim"); -char* _PREHASH_Script = LLMessageStringTable::getInstance()->getString("Script"); -char* _PREHASH_PickInfoReply = LLMessageStringTable::getInstance()->getString("PickInfoReply"); -char* _PREHASH_MoneyBalanceReply = LLMessageStringTable::getInstance()->getString("MoneyBalanceReply"); -char* _PREHASH_RoutedMoneyBalanceReply = LLMessageStringTable::getInstance()->getString("RoutedMoneyBalanceReply"); -char* _PREHASH_RoleID = LLMessageStringTable::getInstance()->getString("RoleID"); -char* _PREHASH_RegionInfo = LLMessageStringTable::getInstance()->getString("RegionInfo"); -char* _PREHASH_GodUpdateRegionInfo = LLMessageStringTable::getInstance()->getString("GodUpdateRegionInfo"); -char* _PREHASH_StartAnim = LLMessageStringTable::getInstance()->getString("StartAnim"); -char* _PREHASH_Action = LLMessageStringTable::getInstance()->getString("Action"); -char* _PREHASH_Location = LLMessageStringTable::getInstance()->getString("Location"); -char* _PREHASH_Rights = LLMessageStringTable::getInstance()->getString("Rights"); -char* _PREHASH_SearchDir = LLMessageStringTable::getInstance()->getString("SearchDir"); -char* _PREHASH_TransferRequest = LLMessageStringTable::getInstance()->getString("TransferRequest"); -char* _PREHASH_ScriptSensorRequest = LLMessageStringTable::getInstance()->getString("ScriptSensorRequest"); -char* _PREHASH_MoneyTransferRequest = LLMessageStringTable::getInstance()->getString("MoneyTransferRequest"); -char* _PREHASH_EjectGroupMemberRequest = LLMessageStringTable::getInstance()->getString("EjectGroupMemberRequest"); -char* _PREHASH_SkillsText = LLMessageStringTable::getInstance()->getString("SkillsText"); -char* _PREHASH_Resent = LLMessageStringTable::getInstance()->getString("Resent"); -char* _PREHASH_Center = LLMessageStringTable::getInstance()->getString("Center"); -char* _PREHASH_SharedData = LLMessageStringTable::getInstance()->getString("SharedData"); -char* _PREHASH_PSBlock = LLMessageStringTable::getInstance()->getString("PSBlock"); -char* _PREHASH_UUIDNameBlock = LLMessageStringTable::getInstance()->getString("UUIDNameBlock"); -char* _PREHASH_GroupTitleUpdate = LLMessageStringTable::getInstance()->getString("GroupTitleUpdate"); -char* _PREHASH_Method = LLMessageStringTable::getInstance()->getString("Method"); -char* _PREHASH_TouchName = LLMessageStringTable::getInstance()->getString("TouchName"); -char* _PREHASH_UpdateType = LLMessageStringTable::getInstance()->getString("UpdateType"); -char* _PREHASH_KickedFromEstateID = LLMessageStringTable::getInstance()->getString("KickedFromEstateID"); -char* _PREHASH_CandidateID = LLMessageStringTable::getInstance()->getString("CandidateID"); -char* _PREHASH_ParamData = LLMessageStringTable::getInstance()->getString("ParamData"); -char* _PREHASH_GodlikeMessage = LLMessageStringTable::getInstance()->getString("GodlikeMessage"); -char* _PREHASH_SystemMessage = LLMessageStringTable::getInstance()->getString("SystemMessage"); -char* _PREHASH_BodyRotation = LLMessageStringTable::getInstance()->getString("BodyRotation"); -char* _PREHASH_SearchRegions = LLMessageStringTable::getInstance()->getString("SearchRegions"); -char* _PREHASH_AnimationData = LLMessageStringTable::getInstance()->getString("AnimationData"); -char* _PREHASH_StatID = LLMessageStringTable::getInstance()->getString("StatID"); -char* _PREHASH_ItemID = LLMessageStringTable::getInstance()->getString("ItemID"); -char* _PREHASH_ScriptDialogReply = LLMessageStringTable::getInstance()->getString("ScriptDialogReply"); -char* _PREHASH_RegionIDAndHandleReply = LLMessageStringTable::getInstance()->getString("RegionIDAndHandleReply"); -char* _PREHASH_CameraAtOffset = LLMessageStringTable::getInstance()->getString("CameraAtOffset"); -char* _PREHASH_VoteID = LLMessageStringTable::getInstance()->getString("VoteID"); -char* _PREHASH_ParcelGodForceOwner = LLMessageStringTable::getInstance()->getString("ParcelGodForceOwner"); -char* _PREHASH_Filter = LLMessageStringTable::getInstance()->getString("Filter"); -char* _PREHASH_InviteData = LLMessageStringTable::getInstance()->getString("InviteData"); -char* _PREHASH_PCode = LLMessageStringTable::getInstance()->getString("PCode"); -char* _PREHASH_SearchPos = LLMessageStringTable::getInstance()->getString("SearchPos"); -char* _PREHASH_PreyID = LLMessageStringTable::getInstance()->getString("PreyID"); -char* _PREHASH_TerrainLowerLimit = LLMessageStringTable::getInstance()->getString("TerrainLowerLimit"); -char* _PREHASH_EventFlags = LLMessageStringTable::getInstance()->getString("EventFlags"); -char* _PREHASH_TallyVotes = LLMessageStringTable::getInstance()->getString("TallyVotes"); -char* _PREHASH_Result = LLMessageStringTable::getInstance()->getString("Result"); -char* _PREHASH_LookAt = LLMessageStringTable::getInstance()->getString("LookAt"); -char* _PREHASH_SearchOrder = LLMessageStringTable::getInstance()->getString("SearchOrder"); -char* _PREHASH_PayButton = LLMessageStringTable::getInstance()->getString("PayButton"); -char* _PREHASH_SelfCount = LLMessageStringTable::getInstance()->getString("SelfCount"); -char* _PREHASH_PacketCount = LLMessageStringTable::getInstance()->getString("PacketCount"); -char* _PREHASH_ParcelBuyPass = LLMessageStringTable::getInstance()->getString("ParcelBuyPass"); -char* _PREHASH_OldItemID = LLMessageStringTable::getInstance()->getString("OldItemID"); -char* _PREHASH_RegionPort = LLMessageStringTable::getInstance()->getString("RegionPort"); -char* _PREHASH_PriceEnergyUnit = LLMessageStringTable::getInstance()->getString("PriceEnergyUnit"); -char* _PREHASH_Bitmap = LLMessageStringTable::getInstance()->getString("Bitmap"); -char* _PREHASH_CacheMissType = LLMessageStringTable::getInstance()->getString("CacheMissType"); -char* _PREHASH_VFileID = LLMessageStringTable::getInstance()->getString("VFileID"); -char* _PREHASH_GroupInsigniaID = LLMessageStringTable::getInstance()->getString("GroupInsigniaID"); -char* _PREHASH_Online = LLMessageStringTable::getInstance()->getString("Online"); -char* _PREHASH_KickFlags = LLMessageStringTable::getInstance()->getString("KickFlags"); -char* _PREHASH_CovenantID = LLMessageStringTable::getInstance()->getString("CovenantID"); -char* _PREHASH_SysCPU = LLMessageStringTable::getInstance()->getString("SysCPU"); -char* _PREHASH_EMail = LLMessageStringTable::getInstance()->getString("EMail"); -char* _PREHASH_AggregatePermTextures = LLMessageStringTable::getInstance()->getString("AggregatePermTextures"); -char* _PREHASH_ChatChannel = LLMessageStringTable::getInstance()->getString("ChatChannel"); -char* _PREHASH_ReturnID = LLMessageStringTable::getInstance()->getString("ReturnID"); -char* _PREHASH_ObjectAttach = LLMessageStringTable::getInstance()->getString("ObjectAttach"); -char* _PREHASH_TargetPort = LLMessageStringTable::getInstance()->getString("TargetPort"); -char* _PREHASH_ObjectSpinStop = LLMessageStringTable::getInstance()->getString("ObjectSpinStop"); -char* _PREHASH_FullID = LLMessageStringTable::getInstance()->getString("FullID"); -char* _PREHASH_ActivateGroup = LLMessageStringTable::getInstance()->getString("ActivateGroup"); -char* _PREHASH_SysGPU = LLMessageStringTable::getInstance()->getString("SysGPU"); -char* _PREHASH_AvatarInterestsReply = LLMessageStringTable::getInstance()->getString("AvatarInterestsReply"); -char* _PREHASH_StartLure = LLMessageStringTable::getInstance()->getString("StartLure"); -char* _PREHASH_SysRAM = LLMessageStringTable::getInstance()->getString("SysRAM"); -char* _PREHASH_ObjectPosition = LLMessageStringTable::getInstance()->getString("ObjectPosition"); -char* _PREHASH_SitPosition = LLMessageStringTable::getInstance()->getString("SitPosition"); -char* _PREHASH_StartTime = LLMessageStringTable::getInstance()->getString("StartTime"); -char* _PREHASH_BornOn = LLMessageStringTable::getInstance()->getString("BornOn"); -char* _PREHASH_CameraCollidePlane = LLMessageStringTable::getInstance()->getString("CameraCollidePlane"); -char* _PREHASH_EconomyDataRequest = LLMessageStringTable::getInstance()->getString("EconomyDataRequest"); -char* _PREHASH_TeleportLureRequest = LLMessageStringTable::getInstance()->getString("TeleportLureRequest"); -char* _PREHASH_FolderID = LLMessageStringTable::getInstance()->getString("FolderID"); -char* _PREHASH_RegionHandleRequest = LLMessageStringTable::getInstance()->getString("RegionHandleRequest"); -char* _PREHASH_ScriptDataRequest = LLMessageStringTable::getInstance()->getString("ScriptDataRequest"); -char* _PREHASH_GroupRoleDataRequest = LLMessageStringTable::getInstance()->getString("GroupRoleDataRequest"); -char* _PREHASH_GroupTitlesRequest = LLMessageStringTable::getInstance()->getString("GroupTitlesRequest"); -char* _PREHASH_AgentWearablesRequest = LLMessageStringTable::getInstance()->getString("AgentWearablesRequest"); -char* _PREHASH_MapBlockRequest = LLMessageStringTable::getInstance()->getString("MapBlockRequest"); -char* _PREHASH_LureID = LLMessageStringTable::getInstance()->getString("LureID"); -char* _PREHASH_CopyCenters = LLMessageStringTable::getInstance()->getString("CopyCenters"); -char* _PREHASH_ParamList = LLMessageStringTable::getInstance()->getString("ParamList"); -char* _PREHASH_InventorySerial = LLMessageStringTable::getInstance()->getString("InventorySerial"); -char* _PREHASH_EdgeDataPacket = LLMessageStringTable::getInstance()->getString("EdgeDataPacket"); -char* _PREHASH_AvatarPickerReply = LLMessageStringTable::getInstance()->getString("AvatarPickerReply"); -char* _PREHASH_ParcelDwellReply = LLMessageStringTable::getInstance()->getString("ParcelDwellReply"); -char* _PREHASH_IsForSale = LLMessageStringTable::getInstance()->getString("IsForSale"); -char* _PREHASH_MuteID = LLMessageStringTable::getInstance()->getString("MuteID"); -char* _PREHASH_MeanCollisionAlert = LLMessageStringTable::getInstance()->getString("MeanCollisionAlert"); -char* _PREHASH_CanAcceptTasks = LLMessageStringTable::getInstance()->getString("CanAcceptTasks"); -char* _PREHASH_ItemData = LLMessageStringTable::getInstance()->getString("ItemData"); -char* _PREHASH_AnimationList = LLMessageStringTable::getInstance()->getString("AnimationList"); -char* _PREHASH_Reputation = LLMessageStringTable::getInstance()->getString("Reputation"); -char* _PREHASH_IntValue = LLMessageStringTable::getInstance()->getString("IntValue"); -char* _PREHASH_TargetType = LLMessageStringTable::getInstance()->getString("TargetType"); -char* _PREHASH_Amount = LLMessageStringTable::getInstance()->getString("Amount"); -char* _PREHASH_HasAttachment = LLMessageStringTable::getInstance()->getString("HasAttachment"); -char* _PREHASH_UpdateAttachment = LLMessageStringTable::getInstance()->getString("UpdateAttachment"); -char* _PREHASH_RemoveAttachment = LLMessageStringTable::getInstance()->getString("RemoveAttachment"); -char* _PREHASH_HeightWidthBlock = LLMessageStringTable::getInstance()->getString("HeightWidthBlock"); -char* _PREHASH_RequestObjectPropertiesFamily = LLMessageStringTable::getInstance()->getString("RequestObjectPropertiesFamily"); -char* _PREHASH_ObjectPropertiesFamily = LLMessageStringTable::getInstance()->getString("ObjectPropertiesFamily"); -char* _PREHASH_UserData = LLMessageStringTable::getInstance()->getString("UserData"); -char* _PREHASH_IsReadable = LLMessageStringTable::getInstance()->getString("IsReadable"); -char* _PREHASH_PathCurve = LLMessageStringTable::getInstance()->getString("PathCurve"); -char* _PREHASH_Status = LLMessageStringTable::getInstance()->getString("Status"); -char* _PREHASH_FromGroup = LLMessageStringTable::getInstance()->getString("FromGroup"); -char* _PREHASH_AlreadyVoted = LLMessageStringTable::getInstance()->getString("AlreadyVoted"); -char* _PREHASH_PlacesReply = LLMessageStringTable::getInstance()->getString("PlacesReply"); -char* _PREHASH_DirPlacesReply = LLMessageStringTable::getInstance()->getString("DirPlacesReply"); -char* _PREHASH_ParcelBuy = LLMessageStringTable::getInstance()->getString("ParcelBuy"); -char* _PREHASH_DirFindQueryBackend = LLMessageStringTable::getInstance()->getString("DirFindQueryBackend"); -char* _PREHASH_DirPlacesQueryBackend = LLMessageStringTable::getInstance()->getString("DirPlacesQueryBackend"); -char* _PREHASH_DirClassifiedQueryBackend = LLMessageStringTable::getInstance()->getString("DirClassifiedQueryBackend"); -char* _PREHASH_DirLandQueryBackend = LLMessageStringTable::getInstance()->getString("DirLandQueryBackend"); -char* _PREHASH_DirPopularQueryBackend = LLMessageStringTable::getInstance()->getString("DirPopularQueryBackend"); -char* _PREHASH_HistoryData = LLMessageStringTable::getInstance()->getString("HistoryData"); -char* _PREHASH_SnapshotID = LLMessageStringTable::getInstance()->getString("SnapshotID"); -char* _PREHASH_Aspect = LLMessageStringTable::getInstance()->getString("Aspect"); -char* _PREHASH_ParamSize = LLMessageStringTable::getInstance()->getString("ParamSize"); -char* _PREHASH_VoteCast = LLMessageStringTable::getInstance()->getString("VoteCast"); -char* _PREHASH_CastsShadows = LLMessageStringTable::getInstance()->getString("CastsShadows"); -char* _PREHASH_EveryoneMask = LLMessageStringTable::getInstance()->getString("EveryoneMask"); -char* _PREHASH_ObjectSpinUpdate = LLMessageStringTable::getInstance()->getString("ObjectSpinUpdate"); -char* _PREHASH_MaturePublish = LLMessageStringTable::getInstance()->getString("MaturePublish"); -char* _PREHASH_UseExistingAsset = LLMessageStringTable::getInstance()->getString("UseExistingAsset"); -char* _PREHASH_Powers = LLMessageStringTable::getInstance()->getString("Powers"); -char* _PREHASH_ParcelLocalID = LLMessageStringTable::getInstance()->getString("ParcelLocalID"); -char* _PREHASH_TeleportCancel = LLMessageStringTable::getInstance()->getString("TeleportCancel"); -char* _PREHASH_UnixTime = LLMessageStringTable::getInstance()->getString("UnixTime"); -char* _PREHASH_QueryFlags = LLMessageStringTable::getInstance()->getString("QueryFlags"); -char* _PREHASH_AlwaysRun = LLMessageStringTable::getInstance()->getString("AlwaysRun"); -char* _PREHASH_Bottom = LLMessageStringTable::getInstance()->getString("Bottom"); -char* _PREHASH_ButtonData = LLMessageStringTable::getInstance()->getString("ButtonData"); -char* _PREHASH_SoundData = LLMessageStringTable::getInstance()->getString("SoundData"); -char* _PREHASH_ViewerStats = LLMessageStringTable::getInstance()->getString("ViewerStats"); -char* _PREHASH_RegionHandshake = LLMessageStringTable::getInstance()->getString("RegionHandshake"); -char* _PREHASH_ObjectDescription = LLMessageStringTable::getInstance()->getString("ObjectDescription"); -char* _PREHASH_Description = LLMessageStringTable::getInstance()->getString("Description"); -char* _PREHASH_ParamType = LLMessageStringTable::getInstance()->getString("ParamType"); -char* _PREHASH_UUIDNameReply = LLMessageStringTable::getInstance()->getString("UUIDNameReply"); -char* _PREHASH_UUIDGroupNameReply = LLMessageStringTable::getInstance()->getString("UUIDGroupNameReply"); -char* _PREHASH_SaveAssetIntoInventory = LLMessageStringTable::getInstance()->getString("SaveAssetIntoInventory"); -char* _PREHASH_UserInfo = LLMessageStringTable::getInstance()->getString("UserInfo"); -char* _PREHASH_AnimSequenceID = LLMessageStringTable::getInstance()->getString("AnimSequenceID"); -char* _PREHASH_NVPairs = LLMessageStringTable::getInstance()->getString("NVPairs"); -char* _PREHASH_GroupNoticesListRequest = LLMessageStringTable::getInstance()->getString("GroupNoticesListRequest"); -char* _PREHASH_ParcelAccessListRequest = LLMessageStringTable::getInstance()->getString("ParcelAccessListRequest"); -char* _PREHASH_MuteListRequest = LLMessageStringTable::getInstance()->getString("MuteListRequest"); -char* _PREHASH_RpcChannelRequest = LLMessageStringTable::getInstance()->getString("RpcChannelRequest"); -char* _PREHASH_LandStatRequest = LLMessageStringTable::getInstance()->getString("LandStatRequest"); -char* _PREHASH_PlacesQuery = LLMessageStringTable::getInstance()->getString("PlacesQuery"); -char* _PREHASH_DirPlacesQuery = LLMessageStringTable::getInstance()->getString("DirPlacesQuery"); -char* _PREHASH_SortOrder = LLMessageStringTable::getInstance()->getString("SortOrder"); -char* _PREHASH_Hunter = LLMessageStringTable::getInstance()->getString("Hunter"); -char* _PREHASH_SunAngVelocity = LLMessageStringTable::getInstance()->getString("SunAngVelocity"); -char* _PREHASH_BinaryBucket = LLMessageStringTable::getInstance()->getString("BinaryBucket"); -char* _PREHASH_ImagePacket = LLMessageStringTable::getInstance()->getString("ImagePacket"); -char* _PREHASH_StartGroupProposal = LLMessageStringTable::getInstance()->getString("StartGroupProposal"); -char* _PREHASH_EnergyLevel = LLMessageStringTable::getInstance()->getString("EnergyLevel"); -char* _PREHASH_PriceForListing = LLMessageStringTable::getInstance()->getString("PriceForListing"); -char* _PREHASH_Scale = LLMessageStringTable::getInstance()->getString("Scale"); -char* _PREHASH_EstateCovenantReply = LLMessageStringTable::getInstance()->getString("EstateCovenantReply"); -char* _PREHASH_ParentEstateID = LLMessageStringTable::getInstance()->getString("ParentEstateID"); -char* _PREHASH_Extra2 = LLMessageStringTable::getInstance()->getString("Extra2"); -char* _PREHASH_Throttle = LLMessageStringTable::getInstance()->getString("Throttle"); -char* _PREHASH_SimIP = LLMessageStringTable::getInstance()->getString("SimIP"); -char* _PREHASH_GodID = LLMessageStringTable::getInstance()->getString("GodID"); -char* _PREHASH_TeleportMinPrice = LLMessageStringTable::getInstance()->getString("TeleportMinPrice"); -char* _PREHASH_VoteItem = LLMessageStringTable::getInstance()->getString("VoteItem"); -char* _PREHASH_ObjectRotation = LLMessageStringTable::getInstance()->getString("ObjectRotation"); -char* _PREHASH_SitRotation = LLMessageStringTable::getInstance()->getString("SitRotation"); -char* _PREHASH_SnapSelection = LLMessageStringTable::getInstance()->getString("SnapSelection"); -char* _PREHASH_SoundTrigger = LLMessageStringTable::getInstance()->getString("SoundTrigger"); -char* _PREHASH_TerrainRaiseLimit = LLMessageStringTable::getInstance()->getString("TerrainRaiseLimit"); -char* _PREHASH_Quorum = LLMessageStringTable::getInstance()->getString("Quorum"); -char* _PREHASH_AgentBlock = LLMessageStringTable::getInstance()->getString("AgentBlock"); -char* _PREHASH_CommandBlock = LLMessageStringTable::getInstance()->getString("CommandBlock"); -char* _PREHASH_PricePublicObjectDecay = LLMessageStringTable::getInstance()->getString("PricePublicObjectDecay"); -char* _PREHASH_SpawnPointPos = LLMessageStringTable::getInstance()->getString("SpawnPointPos"); -char* _PREHASH_VolumeDetail = LLMessageStringTable::getInstance()->getString("VolumeDetail"); -char* _PREHASH_FromAgentName = LLMessageStringTable::getInstance()->getString("FromAgentName"); -char* _PREHASH_Range = LLMessageStringTable::getInstance()->getString("Range"); -char* _PREHASH_DirectoryVisibility = LLMessageStringTable::getInstance()->getString("DirectoryVisibility"); -char* _PREHASH_PublicIP = LLMessageStringTable::getInstance()->getString("PublicIP"); -char* _PREHASH_TeleportFailed = LLMessageStringTable::getInstance()->getString("TeleportFailed"); -char* _PREHASH_PreloadSound = LLMessageStringTable::getInstance()->getString("PreloadSound"); -char* _PREHASH_ScreenshotID = LLMessageStringTable::getInstance()->getString("ScreenshotID"); -char* _PREHASH_CovenantTimestamp = LLMessageStringTable::getInstance()->getString("CovenantTimestamp"); -char* _PREHASH_OldestUnacked = LLMessageStringTable::getInstance()->getString("OldestUnacked"); -char* _PREHASH_SimulatorIP = LLMessageStringTable::getInstance()->getString("SimulatorIP"); -char* _PREHASH_Value = LLMessageStringTable::getInstance()->getString("Value"); -char* _PREHASH_JointAxisOrAnchor = LLMessageStringTable::getInstance()->getString("JointAxisOrAnchor"); -char* _PREHASH_Test0 = LLMessageStringTable::getInstance()->getString("Test0"); -char* _PREHASH_Test1 = LLMessageStringTable::getInstance()->getString("Test1"); -char* _PREHASH_Test2 = LLMessageStringTable::getInstance()->getString("Test2"); -char* _PREHASH_SunPhase = LLMessageStringTable::getInstance()->getString("SunPhase"); -char* _PREHASH_ParcelDivide = LLMessageStringTable::getInstance()->getString("ParcelDivide"); -char* _PREHASH_PriceObjectClaim = LLMessageStringTable::getInstance()->getString("PriceObjectClaim"); -char* _PREHASH_Field = LLMessageStringTable::getInstance()->getString("Field"); -char* _PREHASH_Ratio = LLMessageStringTable::getInstance()->getString("Ratio"); -char* _PREHASH_JoinGroupReply = LLMessageStringTable::getInstance()->getString("JoinGroupReply"); -char* _PREHASH_LiveHelpGroupReply = LLMessageStringTable::getInstance()->getString("LiveHelpGroupReply"); -char* _PREHASH_Score = LLMessageStringTable::getInstance()->getString("Score"); -char* _PREHASH_Image = LLMessageStringTable::getInstance()->getString("Image"); -char* _PREHASH_ObjectClickAction = LLMessageStringTable::getInstance()->getString("ObjectClickAction"); -char* _PREHASH_Parameter = LLMessageStringTable::getInstance()->getString("Parameter"); -char* _PREHASH_Flags = LLMessageStringTable::getInstance()->getString("Flags"); -char* _PREHASH_Plane = LLMessageStringTable::getInstance()->getString("Plane"); -char* _PREHASH_Width = LLMessageStringTable::getInstance()->getString("Width"); -char* _PREHASH_Right = LLMessageStringTable::getInstance()->getString("Right"); -char* _PREHASH_DirFindQuery = LLMessageStringTable::getInstance()->getString("DirFindQuery"); -char* _PREHASH_Textures = LLMessageStringTable::getInstance()->getString("Textures"); -char* _PREHASH_EventData = LLMessageStringTable::getInstance()->getString("EventData"); -char* _PREHASH_Final = LLMessageStringTable::getInstance()->getString("Final"); -char* _PREHASH_System = LLMessageStringTable::getInstance()->getString("System"); -char* _PREHASH_TelehubPos = LLMessageStringTable::getInstance()->getString("TelehubPos"); -char* _PREHASH_ReportAutosaveCrash = LLMessageStringTable::getInstance()->getString("ReportAutosaveCrash"); -char* _PREHASH_CreateTrustedCircuit = LLMessageStringTable::getInstance()->getString("CreateTrustedCircuit"); -char* _PREHASH_DenyTrustedCircuit = LLMessageStringTable::getInstance()->getString("DenyTrustedCircuit"); -char* _PREHASH_RequestTrustedCircuit = LLMessageStringTable::getInstance()->getString("RequestTrustedCircuit"); -char* _PREHASH_Codec = LLMessageStringTable::getInstance()->getString("Codec"); -char* _PREHASH_Modal = LLMessageStringTable::getInstance()->getString("Modal"); -char* _PREHASH_ChildAgentUnknown = LLMessageStringTable::getInstance()->getString("ChildAgentUnknown"); -char* _PREHASH_LandingType = LLMessageStringTable::getInstance()->getString("LandingType"); -char* _PREHASH_ScriptRunningReply = LLMessageStringTable::getInstance()->getString("ScriptRunningReply"); -char* _PREHASH_Reply = LLMessageStringTable::getInstance()->getString("Reply"); -char* _PREHASH_GroupAccountDetailsReply = LLMessageStringTable::getInstance()->getString("GroupAccountDetailsReply"); -char* _PREHASH_TelehubRot = LLMessageStringTable::getInstance()->getString("TelehubRot"); -char* _PREHASH_AcceptFriendship = LLMessageStringTable::getInstance()->getString("AcceptFriendship"); -char* _PREHASH_ItemType = LLMessageStringTable::getInstance()->getString("ItemType"); -char* _PREHASH_DwellInfo = LLMessageStringTable::getInstance()->getString("DwellInfo"); -char* _PREHASH_AgentResume = LLMessageStringTable::getInstance()->getString("AgentResume"); -char* _PREHASH_MailFilter = LLMessageStringTable::getInstance()->getString("MailFilter"); -char* _PREHASH_Disconnect = LLMessageStringTable::getInstance()->getString("Disconnect"); -char* _PREHASH_SimPosition = LLMessageStringTable::getInstance()->getString("SimPosition"); -char* _PREHASH_SimWideTotalPrims = LLMessageStringTable::getInstance()->getString("SimWideTotalPrims"); -char* _PREHASH_Index = LLMessageStringTable::getInstance()->getString("Index"); -char* _PREHASH_SimFilename = LLMessageStringTable::getInstance()->getString("SimFilename"); -char* _PREHASH_LastOwnerID = LLMessageStringTable::getInstance()->getString("LastOwnerID"); -char* _PREHASH_GroupNoticeRequest = LLMessageStringTable::getInstance()->getString("GroupNoticeRequest"); -char* _PREHASH_EmailMessageRequest = LLMessageStringTable::getInstance()->getString("EmailMessageRequest"); -char* _PREHASH_MapItemRequest = LLMessageStringTable::getInstance()->getString("MapItemRequest"); -char* _PREHASH_AgentCount = LLMessageStringTable::getInstance()->getString("AgentCount"); -char* _PREHASH_MessageBlock = LLMessageStringTable::getInstance()->getString("MessageBlock"); -char* _PREHASH_FuseBlock = LLMessageStringTable::getInstance()->getString("FuseBlock"); -char* _PREHASH_AgentGroupData = LLMessageStringTable::getInstance()->getString("AgentGroupData"); -char* _PREHASH_ClassifiedInfoUpdate = LLMessageStringTable::getInstance()->getString("ClassifiedInfoUpdate"); -char* _PREHASH_RegionPos = LLMessageStringTable::getInstance()->getString("RegionPos"); -char* _PREHASH_ParcelMediaUpdate = LLMessageStringTable::getInstance()->getString("ParcelMediaUpdate"); -char* _PREHASH_NoticeID = LLMessageStringTable::getInstance()->getString("NoticeID"); -char* _PREHASH_GridX = LLMessageStringTable::getInstance()->getString("GridX"); -char* _PREHASH_GridY = LLMessageStringTable::getInstance()->getString("GridY"); -char* _PREHASH_Title = LLMessageStringTable::getInstance()->getString("Title"); -char* _PREHASH_AuctionID = LLMessageStringTable::getInstance()->getString("AuctionID"); -char* _PREHASH_VoteType = LLMessageStringTable::getInstance()->getString("VoteType"); -char* _PREHASH_CategoryID = LLMessageStringTable::getInstance()->getString("CategoryID"); -char* _PREHASH_Token = LLMessageStringTable::getInstance()->getString("Token"); -char* _PREHASH_AggregatePerms = LLMessageStringTable::getInstance()->getString("AggregatePerms"); -char* _PREHASH_ObjectSelect = LLMessageStringTable::getInstance()->getString("ObjectSelect"); -char* _PREHASH_ForceObjectSelect = LLMessageStringTable::getInstance()->getString("ForceObjectSelect"); -char* _PREHASH_Price = LLMessageStringTable::getInstance()->getString("Price"); -char* _PREHASH_SunDirection = LLMessageStringTable::getInstance()->getString("SunDirection"); -char* _PREHASH_FromName = LLMessageStringTable::getInstance()->getString("FromName"); -char* _PREHASH_ChangeInventoryItemFlags = LLMessageStringTable::getInstance()->getString("ChangLLInventoryItemFlags"); -char* _PREHASH_Force = LLMessageStringTable::getInstance()->getString("Force"); -char* _PREHASH_TransactionBlock = LLMessageStringTable::getInstance()->getString("TransactionBlock"); -char* _PREHASH_PowersMask = LLMessageStringTable::getInstance()->getString("PowersMask"); -char* _PREHASH_Stamp = LLMessageStringTable::getInstance()->getString("Stamp"); -char* _PREHASH_TotalCredits = LLMessageStringTable::getInstance()->getString("TotalCredits"); -char* _PREHASH_State = LLMessageStringTable::getInstance()->getString("State"); -char* _PREHASH_TextureIndex = LLMessageStringTable::getInstance()->getString("TextureIndex"); -char* _PREHASH_InviteeID = LLMessageStringTable::getInstance()->getString("InviteeID"); -char* _PREHASH_ParcelReclaim = LLMessageStringTable::getInstance()->getString("ParcelReclaim"); -char* _PREHASH_Money = LLMessageStringTable::getInstance()->getString("Money"); -char* _PREHASH_PathTwist = LLMessageStringTable::getInstance()->getString("PathTwist"); -char* _PREHASH_AuthBuyerID = LLMessageStringTable::getInstance()->getString("AuthBuyerID"); -char* _PREHASH_Color = LLMessageStringTable::getInstance()->getString("Color"); -char* _PREHASH_SourceType = LLMessageStringTable::getInstance()->getString("SourceType"); -char* _PREHASH_World = LLMessageStringTable::getInstance()->getString("World"); -char* _PREHASH_QueryData = LLMessageStringTable::getInstance()->getString("QueryData"); -char* _PREHASH_Users = LLMessageStringTable::getInstance()->getString("Users"); -char* _PREHASH_SysOS = LLMessageStringTable::getInstance()->getString("SysOS"); -char* _PREHASH_Notes = LLMessageStringTable::getInstance()->getString("Notes"); -char* _PREHASH_AvatarID = LLMessageStringTable::getInstance()->getString("AvatarID"); -char* _PREHASH_FounderID = LLMessageStringTable::getInstance()->getString("FounderID"); -char* _PREHASH_EndPointID = LLMessageStringTable::getInstance()->getString("EndPointID"); -char* _PREHASH_LocationLookAt = LLMessageStringTable::getInstance()->getString("LocationLookAt"); -char* _PREHASH_Sound = LLMessageStringTable::getInstance()->getString("Sound"); -char* _PREHASH_Cover = LLMessageStringTable::getInstance()->getString("Cover"); -char* _PREHASH_TotalObjectCount = LLMessageStringTable::getInstance()->getString("TotalObjectCount"); -char* _PREHASH_TextureEntry = LLMessageStringTable::getInstance()->getString("TextureEntry"); -char* _PREHASH_SquareMetersCommitted = LLMessageStringTable::getInstance()->getString("SquareMetersCommitted"); -char* _PREHASH_ChannelID = LLMessageStringTable::getInstance()->getString("ChannelID"); -char* _PREHASH_Dwell = LLMessageStringTable::getInstance()->getString("Dwell"); -char* _PREHASH_North = LLMessageStringTable::getInstance()->getString("North"); -char* _PREHASH_AgentUpdate = LLMessageStringTable::getInstance()->getString("AgentUpdate"); -char* _PREHASH_PickGodDelete = LLMessageStringTable::getInstance()->getString("PickGodDelete"); -char* _PREHASH_HostName = LLMessageStringTable::getInstance()->getString("HostName"); -char* _PREHASH_PriceParcelClaim = LLMessageStringTable::getInstance()->getString("PriceParcelClaim"); -char* _PREHASH_ParcelClaim = LLMessageStringTable::getInstance()->getString("ParcelClaim"); -char* _PREHASH_AgentPowers = LLMessageStringTable::getInstance()->getString("AgentPowers"); -char* _PREHASH_ProfileHollow = LLMessageStringTable::getInstance()->getString("ProfileHollow"); -char* _PREHASH_GroupRoleChanges = LLMessageStringTable::getInstance()->getString("GroupRoleChanges"); -char* _PREHASH_Count = LLMessageStringTable::getInstance()->getString("Count"); -char* _PREHASH_South = LLMessageStringTable::getInstance()->getString("South"); -char* _PREHASH_ObjectUpdateCompressed = LLMessageStringTable::getInstance()->getString("ObjectUpdateCompressed"); -char* _PREHASH_MuteFlags = LLMessageStringTable::getInstance()->getString("MuteFlags"); -char* _PREHASH_Group = LLMessageStringTable::getInstance()->getString("Group"); -char* _PREHASH_AgentPause = LLMessageStringTable::getInstance()->getString("AgentPause"); -char* _PREHASH_LanguagesText = LLMessageStringTable::getInstance()->getString("LanguagesText"); -char* _PREHASH_Error = LLMessageStringTable::getInstance()->getString("Error"); -char* _PREHASH_InternalScriptMail = LLMessageStringTable::getInstance()->getString("InternalScriptMail"); -char* _PREHASH_FindAgent = LLMessageStringTable::getInstance()->getString("FindAgent"); -char* _PREHASH_AgentData = LLMessageStringTable::getInstance()->getString("AgentData"); -char* _PREHASH_FolderData = LLMessageStringTable::getInstance()->getString("FolderData"); -char* _PREHASH_AssetBlock = LLMessageStringTable::getInstance()->getString("AssetBlock"); -char* _PREHASH_AcceptNotices = LLMessageStringTable::getInstance()->getString("AcceptNotices"); -char* _PREHASH_SetGroupAcceptNotices = LLMessageStringTable::getInstance()->getString("SetGroupAcceptNotices"); -char* _PREHASH_CloseCircuit = LLMessageStringTable::getInstance()->getString("CloseCircuit"); -char* _PREHASH_TeleportFinish = LLMessageStringTable::getInstance()->getString("TeleportFinish"); -char* _PREHASH_PathRevolutions = LLMessageStringTable::getInstance()->getString("PathRevolutions"); -char* _PREHASH_ClassifiedInfoReply = LLMessageStringTable::getInstance()->getString("ClassifiedInfoReply"); -char* _PREHASH_ParcelInfoReply = LLMessageStringTable::getInstance()->getString("ParcelInfoReply"); -char* _PREHASH_AutosaveData = LLMessageStringTable::getInstance()->getString("AutosaveData"); -char* _PREHASH_SetStartLocation = LLMessageStringTable::getInstance()->getString("SetStartLocation"); -char* _PREHASH_PassHours = LLMessageStringTable::getInstance()->getString("PassHours"); -char* _PREHASH_AttachmentPt = LLMessageStringTable::getInstance()->getString("AttachmentPt"); -char* _PREHASH_ParcelFlags = LLMessageStringTable::getInstance()->getString("ParcelFlags"); -char* _PREHASH_NumVotes = LLMessageStringTable::getInstance()->getString("NumVotes"); -char* _PREHASH_AvatarPickerRequest = LLMessageStringTable::getInstance()->getString("AvatarPickerRequest"); -char* _PREHASH_TeleportLocationRequest = LLMessageStringTable::getInstance()->getString("TeleportLocationRequest"); -char* _PREHASH_DataHomeLocationRequest = LLMessageStringTable::getInstance()->getString("DataHomeLocationRequest"); -char* _PREHASH_EventNotificationAddRequest = LLMessageStringTable::getInstance()->getString("EventNotificationAddRequest"); -char* _PREHASH_ParcelDwellRequest = LLMessageStringTable::getInstance()->getString("ParcelDwellRequest"); -char* _PREHASH_EventLocationRequest = LLMessageStringTable::getInstance()->getString("EventLocationRequest"); -char* _PREHASH_SetStartLocationRequest = LLMessageStringTable::getInstance()->getString("SetStartLocationRequest"); -char* _PREHASH_QueryStart = LLMessageStringTable::getInstance()->getString("QueryStart"); -char* _PREHASH_EjectData = LLMessageStringTable::getInstance()->getString("EjectData"); -char* _PREHASH_AvatarTextureUpdate = LLMessageStringTable::getInstance()->getString("AvatarTextureUpdate"); -char* _PREHASH_RPCServerPort = LLMessageStringTable::getInstance()->getString("RPCServerPort"); -char* _PREHASH_Bytes = LLMessageStringTable::getInstance()->getString("Bytes"); -char* _PREHASH_Extra = LLMessageStringTable::getInstance()->getString("Extra"); -char* _PREHASH_ForceScriptControlRelease = LLMessageStringTable::getInstance()->getString("ForceScriptControlRelease"); -char* _PREHASH_ParcelRelease = LLMessageStringTable::getInstance()->getString("ParcelRelease"); -char* _PREHASH_VFileType = LLMessageStringTable::getInstance()->getString("VFileType"); -char* _PREHASH_EjectGroupMemberReply = LLMessageStringTable::getInstance()->getString("EjectGroupMemberReply"); -char* _PREHASH_ImageData = LLMessageStringTable::getInstance()->getString("ImageData"); -char* _PREHASH_SimulatorViewerTimeMessage = LLMessageStringTable::getInstance()->getString("SimulatorViewerTimeMessage"); -char* _PREHASH_Rotation = LLMessageStringTable::getInstance()->getString("Rotation"); -char* _PREHASH_Selection = LLMessageStringTable::getInstance()->getString("Selection"); -char* _PREHASH_TransactionData = LLMessageStringTable::getInstance()->getString("TransactionData"); -char* _PREHASH_OperationData = LLMessageStringTable::getInstance()->getString("OperationData"); -char* _PREHASH_ExpirationDate = LLMessageStringTable::getInstance()->getString("ExpirationDate"); -char* _PREHASH_ParcelDeedToGroup = LLMessageStringTable::getInstance()->getString("ParcelDeedToGroup"); -char* _PREHASH_AvatarPicksReply = LLMessageStringTable::getInstance()->getString("AvatarPicksReply"); -char* _PREHASH_GroupTitlesReply = LLMessageStringTable::getInstance()->getString("GroupTitlesReply"); -char* _PREHASH_AgentInfo = LLMessageStringTable::getInstance()->getString("AgentInfo"); -char* _PREHASH_MoneyTransferBackend = LLMessageStringTable::getInstance()->getString("MoneyTransferBackend"); -char* _PREHASH_NextOwnerMask = LLMessageStringTable::getInstance()->getString("NextOwnerMask"); -char* _PREHASH_MuteData = LLMessageStringTable::getInstance()->getString("MuteData"); -char* _PREHASH_PassPrice = LLMessageStringTable::getInstance()->getString("PassPrice"); -char* _PREHASH_SourceID = LLMessageStringTable::getInstance()->getString("SourceID"); -char* _PREHASH_ChangeUserRights = LLMessageStringTable::getInstance()->getString("ChangeUserRights"); -char* _PREHASH_TeleportFlags = LLMessageStringTable::getInstance()->getString("TeleportFlags"); -char* _PREHASH_SlaveParcelData = LLMessageStringTable::getInstance()->getString("SlaveParcelData"); -char* _PREHASH_AssetData = LLMessageStringTable::getInstance()->getString("AssetData"); -char* _PREHASH_MultipleObjectUpdate = LLMessageStringTable::getInstance()->getString("MultipleObjectUpdate"); -char* _PREHASH_ObjectUpdate = LLMessageStringTable::getInstance()->getString("ObjectUpdate"); -char* _PREHASH_ImprovedTerseObjectUpdate = LLMessageStringTable::getInstance()->getString("ImprovedTerseObjectUpdate"); -char* _PREHASH_ConfirmXferPacket = LLMessageStringTable::getInstance()->getString("ConfirmXferPacket"); -char* _PREHASH_StartPingCheck = LLMessageStringTable::getInstance()->getString("StartPingCheck"); -char* _PREHASH_SimWideDeletes = LLMessageStringTable::getInstance()->getString("SimWideDeletes"); -char* _PREHASH_LandStatReply = LLMessageStringTable::getInstance()->getString("LandStatReply"); -char* _PREHASH_IsPhantom = LLMessageStringTable::getInstance()->getString("IsPhantom"); -char* _PREHASH_AgentList = LLMessageStringTable::getInstance()->getString("AgentList"); -char* _PREHASH_SimApproved = LLMessageStringTable::getInstance()->getString("SimApproved"); -char* _PREHASH_RezObject = LLMessageStringTable::getInstance()->getString("RezObject"); -char* _PREHASH_TaskLocalID = LLMessageStringTable::getInstance()->getString("TaskLocalID"); -char* _PREHASH_ClaimDate = LLMessageStringTable::getInstance()->getString("ClaimDate"); -char* _PREHASH_MergeParcel = LLMessageStringTable::getInstance()->getString("MergeParcel"); -char* _PREHASH_Priority = LLMessageStringTable::getInstance()->getString("Priority"); -char* _PREHASH_QueryText = LLMessageStringTable::getInstance()->getString("QueryText"); -char* _PREHASH_GroupNoticeAdd = LLMessageStringTable::getInstance()->getString("GroupNoticeAdd"); -char* _PREHASH_ReturnType = LLMessageStringTable::getInstance()->getString("ReturnType"); -char* _PREHASH_FetchFolders = LLMessageStringTable::getInstance()->getString("FetchFolders"); -char* _PREHASH_SimulatorPublicHostBlock = LLMessageStringTable::getInstance()->getString("SimulatorPublicHostBlock"); -char* _PREHASH_HeaderData = LLMessageStringTable::getInstance()->getString("HeaderData"); -char* _PREHASH_RequestMultipleObjects = LLMessageStringTable::getInstance()->getString("RequestMultipleObjects"); -char* _PREHASH_RetrieveInstantMessages = LLMessageStringTable::getInstance()->getString("RetrieveInstantMessages"); -char* _PREHASH_OpenCircuit = LLMessageStringTable::getInstance()->getString("OpenCircuit"); -char* _PREHASH_CrossedRegion = LLMessageStringTable::getInstance()->getString("CrossedRegion"); -char* _PREHASH_DirGroupsReply = LLMessageStringTable::getInstance()->getString("DirGroupsReply"); -char* _PREHASH_AvatarGroupsReply = LLMessageStringTable::getInstance()->getString("AvatarGroupsReply"); -char* _PREHASH_EmailMessageReply = LLMessageStringTable::getInstance()->getString("EmailMessageReply"); -char* _PREHASH_GroupVoteHistoryItemReply = LLMessageStringTable::getInstance()->getString("GroupVoteHistoryItemReply"); -char* _PREHASH_ViewerPosition = LLMessageStringTable::getInstance()->getString("ViewerPosition"); -char* _PREHASH_Position = LLMessageStringTable::getInstance()->getString("Position"); -char* _PREHASH_ParentEstate = LLMessageStringTable::getInstance()->getString("ParentEstate"); -char* _PREHASH_EstateName = LLMessageStringTable::getInstance()->getString("EstateName"); -char* _PREHASH_MuteName = LLMessageStringTable::getInstance()->getString("MuteName"); -char* _PREHASH_ParcelRename = LLMessageStringTable::getInstance()->getString("ParcelRename"); -char* _PREHASH_ViewerFilename = LLMessageStringTable::getInstance()->getString("ViewerFilename"); -char* _PREHASH_UserReportInternal = LLMessageStringTable::getInstance()->getString("UserReportInternal"); -char* _PREHASH_AvatarPropertiesRequest = LLMessageStringTable::getInstance()->getString("AvatarPropertiesRequest"); -char* _PREHASH_ParcelPropertiesRequest = LLMessageStringTable::getInstance()->getString("ParcelPropertiesRequest"); -char* _PREHASH_GroupProfileRequest = LLMessageStringTable::getInstance()->getString("GroupProfileRequest"); -char* _PREHASH_AgentDataUpdateRequest = LLMessageStringTable::getInstance()->getString("AgentDataUpdateRequest"); -char* _PREHASH_PriceObjectScaleFactor = LLMessageStringTable::getInstance()->getString("PriceObjectScaleFactor"); -char* _PREHASH_OpenEnrollment = LLMessageStringTable::getInstance()->getString("OpenEnrollment"); -char* _PREHASH_GroupData = LLMessageStringTable::getInstance()->getString("GroupData"); -char* _PREHASH_RequestGodlikePowers = LLMessageStringTable::getInstance()->getString("RequestGodlikePowers"); -char* _PREHASH_GrantGodlikePowers = LLMessageStringTable::getInstance()->getString("GrantGodlikePowers"); -char* _PREHASH_TransactionID = LLMessageStringTable::getInstance()->getString("TransactionID"); -char* _PREHASH_DestinationID = LLMessageStringTable::getInstance()->getString("DestinationID"); -char* _PREHASH_Controls = LLMessageStringTable::getInstance()->getString("Controls"); -char* _PREHASH_FirstDetachAll = LLMessageStringTable::getInstance()->getString("FirstDetachAll"); -char* _PREHASH_EstateID = LLMessageStringTable::getInstance()->getString("EstateID"); -char* _PREHASH_ImprovedInstantMessage = LLMessageStringTable::getInstance()->getString("ImprovedInstantMessage"); -char* _PREHASH_CheckParcelSales = LLMessageStringTable::getInstance()->getString("CheckParcelSales"); -char* _PREHASH_ParcelSales = LLMessageStringTable::getInstance()->getString("ParcelSales"); -char* _PREHASH_CurrentInterval = LLMessageStringTable::getInstance()->getString("CurrentInterval"); -char* _PREHASH_PriceRentLight = LLMessageStringTable::getInstance()->getString("PriceRentLight"); -char* _PREHASH_MediaAutoScale = LLMessageStringTable::getInstance()->getString("MediaAutoScale"); -char* _PREHASH_NeighborBlock = LLMessageStringTable::getInstance()->getString("NeighborBlock"); -char* _PREHASH_LayerData = LLMessageStringTable::getInstance()->getString("LayerData"); -char* _PREHASH_NVPairData = LLMessageStringTable::getInstance()->getString("NVPairData"); -char* _PREHASH_TeleportLocal = LLMessageStringTable::getInstance()->getString("TeleportLocal"); -char* _PREHASH_EjecteeID = LLMessageStringTable::getInstance()->getString("EjecteeID"); -char* _PREHASH_VoteInitiator = LLMessageStringTable::getInstance()->getString("VoteInitiator"); -char* _PREHASH_TypeData = LLMessageStringTable::getInstance()->getString("TypeData"); -char* _PREHASH_OwnerIDs = LLMessageStringTable::getInstance()->getString("OwnerIDs"); -char* _PREHASH_SystemKickUser = LLMessageStringTable::getInstance()->getString("SystemKickUser"); -char* _PREHASH_TransactionTime = LLMessageStringTable::getInstance()->getString("TransactionTime"); -char* _PREHASH_TimeToLive = LLMessageStringTable::getInstance()->getString("TimeToLive"); -char* _PREHASH_OldAgentID = LLMessageStringTable::getInstance()->getString("OldAgentID"); -char* _PREHASH_MusicURL = LLMessageStringTable::getInstance()->getString("MusicURL"); -char* _PREHASH_ParcelPrimBonus = LLMessageStringTable::getInstance()->getString("ParcelPrimBonus"); -char* _PREHASH_EjectUser = LLMessageStringTable::getInstance()->getString("EjectUser"); -char* _PREHASH_CoarseLocationUpdate = LLMessageStringTable::getInstance()->getString("CoarseLocationUpdate"); -char* _PREHASH_ChildAgentPositionUpdate = LLMessageStringTable::getInstance()->getString("ChildAgentPositionUpdate"); -char* _PREHASH_StoreLocal = LLMessageStringTable::getInstance()->getString("StoreLocal"); -char* _PREHASH_GroupName = LLMessageStringTable::getInstance()->getString("GroupName"); -char* _PREHASH_PriceParcelRent = LLMessageStringTable::getInstance()->getString("PriceParcelRent"); -char* _PREHASH_SimStatus = LLMessageStringTable::getInstance()->getString("SimStatus"); -char* _PREHASH_TransactionSuccess = LLMessageStringTable::getInstance()->getString("TransactionSuccess"); -char* _PREHASH_LureType = LLMessageStringTable::getInstance()->getString("LureType"); -char* _PREHASH_GroupMask = LLMessageStringTable::getInstance()->getString("GroupMask"); -char* _PREHASH_SitObject = LLMessageStringTable::getInstance()->getString("SitObject"); -char* _PREHASH_Override = LLMessageStringTable::getInstance()->getString("Override"); -char* _PREHASH_LocomotionState = LLMessageStringTable::getInstance()->getString("LocomotionState"); -char* _PREHASH_PriceUpload = LLMessageStringTable::getInstance()->getString("PriceUpload"); -char* _PREHASH_RemoveParcel = LLMessageStringTable::getInstance()->getString("RemoveParcel"); -char* _PREHASH_ConfirmAuctionStart = LLMessageStringTable::getInstance()->getString("ConfirmAuctionStart"); -char* _PREHASH_RpcScriptRequestInbound = LLMessageStringTable::getInstance()->getString("RpcScriptRequestInbound"); -char* _PREHASH_ActiveGroupID = LLMessageStringTable::getInstance()->getString("ActiveGroupID"); -char* _PREHASH_ParcelReturnObjects = LLMessageStringTable::getInstance()->getString("ParcelReturnObjects"); -char* _PREHASH_TotalObjects = LLMessageStringTable::getInstance()->getString("TotalObjects"); -char* _PREHASH_ObjectExtraParams = LLMessageStringTable::getInstance()->getString("ObjectExtraParams"); -char* _PREHASH_Questions = LLMessageStringTable::getInstance()->getString("Questions"); -char* _PREHASH_TransferAbort = LLMessageStringTable::getInstance()->getString("TransferAbort"); -char* _PREHASH_TransferInventory = LLMessageStringTable::getInstance()->getString("TransferInventory"); -char* _PREHASH_RayTargetID = LLMessageStringTable::getInstance()->getString("RayTargetID"); -char* _PREHASH_ClaimPrice = LLMessageStringTable::getInstance()->getString("ClaimPrice"); -char* _PREHASH_ObjectProperties = LLMessageStringTable::getInstance()->getString("ObjectProperties"); -char* _PREHASH_ParcelProperties = LLMessageStringTable::getInstance()->getString("ParcelProperties"); -char* _PREHASH_EstateOwnerID = LLMessageStringTable::getInstance()->getString("EstateOwnerID"); -char* _PREHASH_LogoutRequest = LLMessageStringTable::getInstance()->getString("LogoutRequest"); -char* _PREHASH_AssetUploadRequest = LLMessageStringTable::getInstance()->getString("AssetUploadRequest"); -char* _PREHASH_TransactionType = LLMessageStringTable::getInstance()->getString("TransactionType"); -char* _PREHASH_AvatarPropertiesUpdate = LLMessageStringTable::getInstance()->getString("AvatarPropertiesUpdate"); -char* _PREHASH_ParcelPropertiesUpdate = LLMessageStringTable::getInstance()->getString("ParcelPropertiesUpdate"); -char* _PREHASH_FetchItems = LLMessageStringTable::getInstance()->getString("FetchItems"); -char* _PREHASH_AbortXfer = LLMessageStringTable::getInstance()->getString("AbortXfer"); -char* _PREHASH_DeRezAck = LLMessageStringTable::getInstance()->getString("DeRezAck"); -char* _PREHASH_TakeControls = LLMessageStringTable::getInstance()->getString("TakeControls"); -char* _PREHASH_DirLandReply = LLMessageStringTable::getInstance()->getString("DirLandReply"); -char* _PREHASH_MuteType = LLMessageStringTable::getInstance()->getString("MuteType"); -char* _PREHASH_IMViaEMail = LLMessageStringTable::getInstance()->getString("IMViaEMail"); -char* _PREHASH_RentPrice = LLMessageStringTable::getInstance()->getString("RentPrice"); -char* _PREHASH_GenericMessage = LLMessageStringTable::getInstance()->getString("GenericMessage"); -char* _PREHASH_ChildAgentAlive = LLMessageStringTable::getInstance()->getString("ChildAgentAlive"); -char* _PREHASH_AssetType = LLMessageStringTable::getInstance()->getString("AssetType"); -char* _PREHASH_SpawnPointBlock = LLMessageStringTable::getInstance()->getString("SpawnPointBlock"); -char* _PREHASH_AttachmentBlock = LLMessageStringTable::getInstance()->getString("AttachmentBlock"); -char* _PREHASH_ObjectMaterial = LLMessageStringTable::getInstance()->getString("ObjectMaterial"); -char* _PREHASH_OwnerName = LLMessageStringTable::getInstance()->getString("OwnerName"); -char* _PREHASH_AvatarNotesReply = LLMessageStringTable::getInstance()->getString("AvatarNotesReply"); -char* _PREHASH_CacheID = LLMessageStringTable::getInstance()->getString("CacheID"); -char* _PREHASH_OwnerMask = LLMessageStringTable::getInstance()->getString("OwnerMask"); -char* _PREHASH_TransferInventoryAck = LLMessageStringTable::getInstance()->getString("TransferInventoryAck"); -char* _PREHASH_RegionDenyAgeUnverified = LLMessageStringTable::getInstance()->getString("RegionDenyAgeUnverified"); -char* _PREHASH_AgeVerificationBlock = LLMessageStringTable::getInstance()->getString("AgeVerificationBlock"); -char* _PREHASH_UCoord = LLMessageStringTable::getInstance()->getString("UCoord"); -char* _PREHASH_VCoord = LLMessageStringTable::getInstance()->getString("VCoord"); -char* _PREHASH_FaceIndex = LLMessageStringTable::getInstance()->getString("FaceIndex"); -char* _PREHASH_StatusData = LLMessageStringTable::getInstance()->getString("StatusData"); -char* _PREHASH_ProductSKU = LLMessageStringTable::getInstance()->getString("ProductSKU"); +char const* const _PREHASH_X = LLMessageStringTable::getInstance()->getString("X"); +char const* const _PREHASH_Y = LLMessageStringTable::getInstance()->getString("Y"); +char const* const _PREHASH_Z = LLMessageStringTable::getInstance()->getString("Z"); +char const* const _PREHASH_AddFlags = LLMessageStringTable::getInstance()->getString("AddFlags"); +char const* const _PREHASH_FailureInfo = LLMessageStringTable::getInstance()->getString("FailureInfo"); +char const* const _PREHASH_MapData = LLMessageStringTable::getInstance()->getString("MapData"); +char const* const _PREHASH_AddItem = LLMessageStringTable::getInstance()->getString("AddItem"); +char const* const _PREHASH_MeanCollision = LLMessageStringTable::getInstance()->getString("MeanCollision"); +char const* const _PREHASH_RezScript = LLMessageStringTable::getInstance()->getString("RezScript"); +char const* const _PREHASH_AvatarSitResponse = LLMessageStringTable::getInstance()->getString("AvatarSitResponse"); +char const* const _PREHASH_InventoryAssetResponse = LLMessageStringTable::getInstance()->getString("InventoryAssetResponse"); +char const* const _PREHASH_KillObject = LLMessageStringTable::getInstance()->getString("KillObject"); +char const* const _PREHASH_ProposalID = LLMessageStringTable::getInstance()->getString("ProposalID"); +char const* const _PREHASH_SerialNum = LLMessageStringTable::getInstance()->getString("SerialNum"); +char const* const _PREHASH_Duration = LLMessageStringTable::getInstance()->getString("Duration"); +char const* const _PREHASH_ScriptQuestion = LLMessageStringTable::getInstance()->getString("ScriptQuestion"); +char const* const _PREHASH_AddCircuitCode = LLMessageStringTable::getInstance()->getString("AddCircuitCode"); +char const* const _PREHASH_UseCircuitCode = LLMessageStringTable::getInstance()->getString("UseCircuitCode"); +char const* const _PREHASH_ViewerCircuitCode = LLMessageStringTable::getInstance()->getString("ViewerCircuitCode"); +char const* const _PREHASH_ScriptAnswerYes = LLMessageStringTable::getInstance()->getString("ScriptAnswerYes"); +char const* const _PREHASH_PartnerID = LLMessageStringTable::getInstance()->getString("PartnerID"); +char const* const _PREHASH_DirLandQuery = LLMessageStringTable::getInstance()->getString("DirLandQuery"); +char const* const _PREHASH_TeleportStart = LLMessageStringTable::getInstance()->getString("TeleportStart"); +char const* const _PREHASH_AboutText = LLMessageStringTable::getInstance()->getString("AboutText"); +char const* const _PREHASH_VisualParam = LLMessageStringTable::getInstance()->getString("VisualParam"); +char const* const _PREHASH_GroupPrims = LLMessageStringTable::getInstance()->getString("GroupPrims"); +char const* const _PREHASH_SelectedPrims = LLMessageStringTable::getInstance()->getString("SelectedPrims"); +char const* const _PREHASH_ID = LLMessageStringTable::getInstance()->getString("ID"); +char const* const _PREHASH_UUIDNameRequest = LLMessageStringTable::getInstance()->getString("UUIDNameRequest"); +char const* const _PREHASH_UUIDGroupNameRequest = LLMessageStringTable::getInstance()->getString("UUIDGroupNameRequest"); +char const* const _PREHASH_GroupAccountTransactionsRequest = LLMessageStringTable::getInstance()->getString("GroupAccountTransactionsRequest"); +char const* const _PREHASH_MapNameRequest = LLMessageStringTable::getInstance()->getString("MapNameRequest"); +char const* const _PREHASH_UpdateSimulator = LLMessageStringTable::getInstance()->getString("UpdateSimulator"); +char const* const _PREHASH_BillableFactor = LLMessageStringTable::getInstance()->getString("BillableFactor"); +char const* const _PREHASH_ObjectBonusFactor = LLMessageStringTable::getInstance()->getString("ObjectBonusFactor"); +char const* const _PREHASH_EnableSimulator = LLMessageStringTable::getInstance()->getString("EnableSimulator"); +char const* const _PREHASH_DisableSimulator = LLMessageStringTable::getInstance()->getString("DisableSimulator"); +char const* const _PREHASH_ConfirmEnableSimulator = LLMessageStringTable::getInstance()->getString("ConfirmEnableSimulator"); +char const* const _PREHASH_LayerType = LLMessageStringTable::getInstance()->getString("LayerType"); +char const* const _PREHASH_OwnerRole = LLMessageStringTable::getInstance()->getString("OwnerRole"); +char const* const _PREHASH_ParcelOverlay = LLMessageStringTable::getInstance()->getString("ParcelOverlay"); +char const* const _PREHASH_GroupOwned = LLMessageStringTable::getInstance()->getString("GroupOwned"); +char const* const _PREHASH_IP = LLMessageStringTable::getInstance()->getString("IP"); +char const* const _PREHASH_ChatFromViewer = LLMessageStringTable::getInstance()->getString("ChatFromViewer"); +char const* const _PREHASH_AvgAgentsInView = LLMessageStringTable::getInstance()->getString("AvgAgentsInView"); +char const* const _PREHASH_AgentsInView = LLMessageStringTable::getInstance()->getString("AgentsInView"); +char const* const _PREHASH_GroupTitle = LLMessageStringTable::getInstance()->getString("GroupTitle"); +char const* const _PREHASH_MapLayerReply = LLMessageStringTable::getInstance()->getString("MapLayerReply"); +char const* const _PREHASH_CompoundMsgID = LLMessageStringTable::getInstance()->getString("CompoundMsgID"); +char const* const _PREHASH_CameraConstraint = LLMessageStringTable::getInstance()->getString("CameraConstraint"); +char const* const _PREHASH_DownloadTotals = LLMessageStringTable::getInstance()->getString("DownloadTotals"); +char const* const _PREHASH_GenCounter = LLMessageStringTable::getInstance()->getString("GenCounter"); +char const* const _PREHASH_FrozenData = LLMessageStringTable::getInstance()->getString("FrozenData"); +char const* const _PREHASH_ChildAgentDying = LLMessageStringTable::getInstance()->getString("ChildAgentDying"); +char const* const _PREHASH_To = LLMessageStringTable::getInstance()->getString("To"); +char const* const _PREHASH_CopyInventoryFromNotecard = LLMessageStringTable::getInstance()->getString("CopyInventoryFromNotecard"); +char const* const _PREHASH_RezObjectFromNotecard = LLMessageStringTable::getInstance()->getString("RezObjectFromNotecard"); +char const* const _PREHASH_ParcelDirFeeCurrent = LLMessageStringTable::getInstance()->getString("ParcelDirFeeCurrent"); +char const* const _PREHASH_SeedCapability = LLMessageStringTable::getInstance()->getString("SeedCapability"); +char const* const _PREHASH_ObjectDuplicate = LLMessageStringTable::getInstance()->getString("ObjectDuplicate"); +char const* const _PREHASH_InventoryData = LLMessageStringTable::getInstance()->getString("InventoryData"); +char const* const _PREHASH_ReplyData = LLMessageStringTable::getInstance()->getString("ReplyData"); +char const* const _PREHASH_ResetList = LLMessageStringTable::getInstance()->getString("ResetList"); +char const* const _PREHASH_MediaID = LLMessageStringTable::getInstance()->getString("MediaID"); +char const* const _PREHASH_RelatedRights = LLMessageStringTable::getInstance()->getString("RelatedRights"); +char const* const _PREHASH_RedirectGridX = LLMessageStringTable::getInstance()->getString("RedirectGridX"); +char const* const _PREHASH_RedirectGridY = LLMessageStringTable::getInstance()->getString("RedirectGridY"); +char const* const _PREHASH_TransferID = LLMessageStringTable::getInstance()->getString("TransferID"); +char const* const _PREHASH_TexturesChanged = LLMessageStringTable::getInstance()->getString("TexturesChanged"); +char const* const _PREHASH_UserLookAt = LLMessageStringTable::getInstance()->getString("UserLookAt"); +char const* const _PREHASH_TestBlock1 = LLMessageStringTable::getInstance()->getString("TestBlock1"); +char const* const _PREHASH_SensedData = LLMessageStringTable::getInstance()->getString("SensedData"); +char const* const _PREHASH_UpdateBlock = LLMessageStringTable::getInstance()->getString("UpdateBlock"); +char const* const _PREHASH_ClassifiedGodDelete = LLMessageStringTable::getInstance()->getString("ClassifiedGodDelete"); +char const* const _PREHASH_ObjectGrabUpdate = LLMessageStringTable::getInstance()->getString("ObjectGrabUpdate"); +char const* const _PREHASH_LocationPos = LLMessageStringTable::getInstance()->getString("LocationPos"); +char const* const _PREHASH_TaxDate = LLMessageStringTable::getInstance()->getString("TaxDate"); +char const* const _PREHASH_StartDateTime = LLMessageStringTable::getInstance()->getString("StartDateTime"); +char const* const _PREHASH_ObjectUpdateCached = LLMessageStringTable::getInstance()->getString("ObjectUpdateCached"); +char const* const _PREHASH_Packets = LLMessageStringTable::getInstance()->getString("Packets"); +char const* const _PREHASH_FailureType = LLMessageStringTable::getInstance()->getString("FailureType"); +char const* const _PREHASH_UpdateGroupInfo = LLMessageStringTable::getInstance()->getString("UpdateGroupInfo"); +char const* const _PREHASH_ObjectPermissions = LLMessageStringTable::getInstance()->getString("ObjectPermissions"); +char const* const _PREHASH_RevokePermissions = LLMessageStringTable::getInstance()->getString("RevokePermissions"); +char const* const _PREHASH_UpdateFlags = LLMessageStringTable::getInstance()->getString("UpdateFlags"); +char const* const _PREHASH_ObjectExportSelected = LLMessageStringTable::getInstance()->getString("ObjectExportSelected"); +char const* const _PREHASH_RezSelected = LLMessageStringTable::getInstance()->getString("RezSelected"); +char const* const _PREHASH_AutoPilot = LLMessageStringTable::getInstance()->getString("AutoPilot"); +char const* const _PREHASH_UpdateMuteListEntry = LLMessageStringTable::getInstance()->getString("UpdateMuteListEntry"); +char const* const _PREHASH_RemoveMuteListEntry = LLMessageStringTable::getInstance()->getString("RemoveMuteListEntry"); +char const* const _PREHASH_SetSimStatusInDatabase = LLMessageStringTable::getInstance()->getString("SetSimStatusInDatabase"); +char const* const _PREHASH_SetSimPresenceInDatabase = LLMessageStringTable::getInstance()->getString("SetSimPresenceInDatabase"); +char const* const _PREHASH_CameraProperty = LLMessageStringTable::getInstance()->getString("CameraProperty"); +char const* const _PREHASH_BrushSize = LLMessageStringTable::getInstance()->getString("BrushSize"); +char const* const _PREHASH_SimulatorSetMap = LLMessageStringTable::getInstance()->getString("SimulatorSetMap"); +char const* const _PREHASH_RegionPresenceRequestByRegionID = LLMessageStringTable::getInstance()->getString("RegionPresenceRequestByRegionID"); +char const* const _PREHASH_ParcelObjectOwnersReply = LLMessageStringTable::getInstance()->getString("ParcelObjectOwnersReply"); +char const* const _PREHASH_GroupMembersReply = LLMessageStringTable::getInstance()->getString("GroupMembersReply"); +char const* const _PREHASH_GroupRoleMembersReply = LLMessageStringTable::getInstance()->getString("GroupRoleMembersReply"); +char const* const _PREHASH_RequestRegionInfo = LLMessageStringTable::getInstance()->getString("RequestRegionInfo"); +char const* const _PREHASH_AABBMax = LLMessageStringTable::getInstance()->getString("AABBMax"); +char const* const _PREHASH_RequestPayPrice = LLMessageStringTable::getInstance()->getString("RequestPayPrice"); +char const* const _PREHASH_SimulatorPresentAtLocation = LLMessageStringTable::getInstance()->getString("SimulatorPresentAtLocation"); +char const* const _PREHASH_AgentRequestSit = LLMessageStringTable::getInstance()->getString("AgentRequestSit"); +char const* const _PREHASH_AABBMin = LLMessageStringTable::getInstance()->getString("AABBMin"); +char const* const _PREHASH_ClassifiedFlags = LLMessageStringTable::getInstance()->getString("ClassifiedFlags"); +char const* const _PREHASH_ControlFlags = LLMessageStringTable::getInstance()->getString("ControlFlags"); +char const* const _PREHASH_TeleportRequest = LLMessageStringTable::getInstance()->getString("TeleportRequest"); +char const* const _PREHASH_ScriptTeleportRequest = LLMessageStringTable::getInstance()->getString("ScriptTeleportRequest"); +char const* const _PREHASH_EstateCovenantRequest = LLMessageStringTable::getInstance()->getString("EstateCovenantRequest"); +char const* const _PREHASH_DateUTC = LLMessageStringTable::getInstance()->getString("DateUTC"); +char const* const _PREHASH_TaskIDs = LLMessageStringTable::getInstance()->getString("TaskIDs"); +char const* const _PREHASH_RequestResult = LLMessageStringTable::getInstance()->getString("RequestResult"); +char const* const _PREHASH_CanAcceptAgents = LLMessageStringTable::getInstance()->getString("CanAcceptAgents"); +char const* const _PREHASH_ObjectSaleInfo = LLMessageStringTable::getInstance()->getString("ObjectSaleInfo"); +char const* const _PREHASH_KillChildAgents = LLMessageStringTable::getInstance()->getString("KillChildAgents"); +char const* const _PREHASH_Balance = LLMessageStringTable::getInstance()->getString("Balance"); +char const* const _PREHASH_DerezContainer = LLMessageStringTable::getInstance()->getString("DerezContainer"); +char const* const _PREHASH_ObjectData = LLMessageStringTable::getInstance()->getString("ObjectData"); +char const* const _PREHASH_CameraAtAxis = LLMessageStringTable::getInstance()->getString("CameraAtAxis"); +char const* const _PREHASH_InfoBlock = LLMessageStringTable::getInstance()->getString("InfoBlock"); +char const* const _PREHASH_OwnershipCost = LLMessageStringTable::getInstance()->getString("OwnershipCost"); +char const* const _PREHASH_AvatarNotesUpdate = LLMessageStringTable::getInstance()->getString("AvatarNotesUpdate"); +char const* const _PREHASH_PID = LLMessageStringTable::getInstance()->getString("PID"); +char const* const _PREHASH_DirPopularReply = LLMessageStringTable::getInstance()->getString("DirPopularReply"); +char const* const _PREHASH_TerrainHeightRange00 = LLMessageStringTable::getInstance()->getString("TerrainHeightRange00"); +char const* const _PREHASH_SimData = LLMessageStringTable::getInstance()->getString("SimData"); +char const* const _PREHASH_TerrainHeightRange01 = LLMessageStringTable::getInstance()->getString("TerrainHeightRange01"); +char const* const _PREHASH_TerrainHeightRange10 = LLMessageStringTable::getInstance()->getString("TerrainHeightRange10"); +char const* const _PREHASH_TerrainHeightRange11 = LLMessageStringTable::getInstance()->getString("TerrainHeightRange11"); +char const* const _PREHASH_UpdateInventoryItem = LLMessageStringTable::getInstance()->getString("UpdateInventoryItem"); +char const* const _PREHASH_UpdateCreateInventoryItem = LLMessageStringTable::getInstance()->getString("UpdateCreateInventoryItem"); +char const* const _PREHASH_MoveInventoryItem = LLMessageStringTable::getInstance()->getString("MoveInventoryItem"); +char const* const _PREHASH_CopyInventoryItem = LLMessageStringTable::getInstance()->getString("CopyInventoryItem"); +char const* const _PREHASH_LinkInventoryItem = LLMessageStringTable::getInstance()->getString("LinkInventoryItem"); +char const* const _PREHASH_RemoveInventoryItem = LLMessageStringTable::getInstance()->getString("RemoveInventoryItem"); +char const* const _PREHASH_CreateInventoryItem = LLMessageStringTable::getInstance()->getString("CreateInventoryItem"); +char const* const _PREHASH_PathTwistBegin = LLMessageStringTable::getInstance()->getString("PathTwistBegin"); +char const* const _PREHASH_CRC = LLMessageStringTable::getInstance()->getString("CRC"); +char const* const _PREHASH_AttachmentPoint = LLMessageStringTable::getInstance()->getString("AttachmentPoint"); +char const* const _PREHASH_TelehubBlock = LLMessageStringTable::getInstance()->getString("TelehubBlock"); +char const* const _PREHASH_FOVBlock = LLMessageStringTable::getInstance()->getString("FOVBlock"); +char const* const _PREHASH_StartLocationData = LLMessageStringTable::getInstance()->getString("StartLocationData"); +char const* const _PREHASH_PositionData = LLMessageStringTable::getInstance()->getString("PositionData"); +char const* const _PREHASH_TimeSinceLast = LLMessageStringTable::getInstance()->getString("TimeSinceLast"); +char const* const _PREHASH_MapImage = LLMessageStringTable::getInstance()->getString("MapImage"); +char const* const _PREHASH_Objects = LLMessageStringTable::getInstance()->getString("Objects"); +char const* const _PREHASH_URL = LLMessageStringTable::getInstance()->getString("URL"); +char const* const _PREHASH_CreationDate = LLMessageStringTable::getInstance()->getString("CreationDate"); +char const* const _PREHASH_JointPivot = LLMessageStringTable::getInstance()->getString("JointPivot"); +char const* const _PREHASH_FPS = LLMessageStringTable::getInstance()->getString("FPS"); +char const* const _PREHASH_HasTelehub = LLMessageStringTable::getInstance()->getString("HasTelehub"); +char const* const _PREHASH_PathEnd = LLMessageStringTable::getInstance()->getString("PathEnd"); +char const* const _PREHASH_ScriptDataReply = LLMessageStringTable::getInstance()->getString("ScriptDataReply"); +char const* const _PREHASH_MapBlockReply = LLMessageStringTable::getInstance()->getString("MapBlockReply"); +char const* const _PREHASH_PropertiesData = LLMessageStringTable::getInstance()->getString("PropertiesData"); +char const* const _PREHASH_ViewerEffect = LLMessageStringTable::getInstance()->getString("ViewerEffect"); +char const* const _PREHASH_FreezeUser = LLMessageStringTable::getInstance()->getString("FreezeUser"); +char const* const _PREHASH_OwnerPrims = LLMessageStringTable::getInstance()->getString("OwnerPrims"); +char const* const _PREHASH_ObjectGrab = LLMessageStringTable::getInstance()->getString("ObjectGrab"); +char const* const _PREHASH_ToAgentID = LLMessageStringTable::getInstance()->getString("ToAgentID"); +char const* const _PREHASH_SimulatorMapUpdate = LLMessageStringTable::getInstance()->getString("SimulatorMapUpdate"); +char const* const _PREHASH_TransferPacket = LLMessageStringTable::getInstance()->getString("TransferPacket"); +char const* const _PREHASH_ObjectName = LLMessageStringTable::getInstance()->getString("ObjectName"); +char const* const _PREHASH_GroupPowers = LLMessageStringTable::getInstance()->getString("GroupPowers"); +char const* const _PREHASH_OriginalName = LLMessageStringTable::getInstance()->getString("OriginalName"); +char const* const _PREHASH_CompletePingCheck = LLMessageStringTable::getInstance()->getString("CompletePingCheck"); +char const* const _PREHASH_OnlineStatus = LLMessageStringTable::getInstance()->getString("OnlineStatus"); +char const* const _PREHASH_ObjectDrop = LLMessageStringTable::getInstance()->getString("ObjectDrop"); +char const* const _PREHASH_UseBigPackets = LLMessageStringTable::getInstance()->getString("UseBigPackets"); +char const* const _PREHASH_GroupNoticesListReply = LLMessageStringTable::getInstance()->getString("GroupNoticesListReply"); +char const* const _PREHASH_ParcelAccessListReply = LLMessageStringTable::getInstance()->getString("ParcelAccessListReply"); +char const* const _PREHASH_RpcChannelReply = LLMessageStringTable::getInstance()->getString("RpcChannelReply"); +char const* const _PREHASH_RegionPresenceResponse = LLMessageStringTable::getInstance()->getString("RegionPresenceResponse"); +char const* const _PREHASH_CharterMember = LLMessageStringTable::getInstance()->getString("CharterMember"); +char const* const _PREHASH_EdgeData = LLMessageStringTable::getInstance()->getString("EdgeData"); +char const* const _PREHASH_NameData = LLMessageStringTable::getInstance()->getString("NameData"); +char const* const _PREHASH_RegionPushOverride = LLMessageStringTable::getInstance()->getString("RegionPushOverride"); +char const* const _PREHASH_SimName = LLMessageStringTable::getInstance()->getString("SimName"); +char const* const _PREHASH_UserReport = LLMessageStringTable::getInstance()->getString("UserReport"); +char const* const _PREHASH_DownloadPriority = LLMessageStringTable::getInstance()->getString("DownloadPriority"); +char const* const _PREHASH_ToAgentId = LLMessageStringTable::getInstance()->getString("ToAgentId"); +char const* const _PREHASH_DirPopularQuery = LLMessageStringTable::getInstance()->getString("DirPopularQuery"); +char const* const _PREHASH_Mag = LLMessageStringTable::getInstance()->getString("Mag"); +char const* const _PREHASH_ParcelPropertiesRequestByID = LLMessageStringTable::getInstance()->getString("ParcelPropertiesRequestByID"); +char const* const _PREHASH_ObjectLink = LLMessageStringTable::getInstance()->getString("ObjectLink"); +char const* const _PREHASH_RpcScriptReplyInbound = LLMessageStringTable::getInstance()->getString("RpcScriptReplyInbound"); +char const* const _PREHASH_RezData = LLMessageStringTable::getInstance()->getString("RezData"); +char const* const _PREHASH_RemoveInventoryObjects = LLMessageStringTable::getInstance()->getString("RemoveInventoryObjects"); +char const* const _PREHASH_GroupProposalBallot = LLMessageStringTable::getInstance()->getString("GroupProposalBallot"); +char const* const _PREHASH_RPCServerIP = LLMessageStringTable::getInstance()->getString("RPCServerIP"); +char const* const _PREHASH_Far = LLMessageStringTable::getInstance()->getString("Far"); +char const* const _PREHASH_GodSessionID = LLMessageStringTable::getInstance()->getString("GodSessionID"); +char const* const _PREHASH_FLAboutText = LLMessageStringTable::getInstance()->getString("FLAboutText"); +char const* const _PREHASH_RegionHandshakeReply = LLMessageStringTable::getInstance()->getString("RegionHandshakeReply"); +char const* const _PREHASH_GroupActiveProposalItemReply = LLMessageStringTable::getInstance()->getString("GroupActiveProposalItemReply"); +char const* const _PREHASH_MapItemReply = LLMessageStringTable::getInstance()->getString("MapItemReply"); +char const* const _PREHASH_Seconds = LLMessageStringTable::getInstance()->getString("Seconds"); +char const* const _PREHASH_UpdateUserInfo = LLMessageStringTable::getInstance()->getString("UpdateUserInfo"); +char const* const _PREHASH_AggregatePermTexturesOwner = LLMessageStringTable::getInstance()->getString("AggregatePermTexturesOwner"); +char const* const _PREHASH_Set = LLMessageStringTable::getInstance()->getString("Set"); +char const* const _PREHASH_NewName = LLMessageStringTable::getInstance()->getString("NewName"); +char const* const _PREHASH_Key = LLMessageStringTable::getInstance()->getString("Key"); +char const* const _PREHASH_AgentID = LLMessageStringTable::getInstance()->getString("AgentID"); +char const* const _PREHASH_EventNotificationRemoveRequest = LLMessageStringTable::getInstance()->getString("EventNotificationRemoveRequest"); +char const* const _PREHASH_NewFolderID = LLMessageStringTable::getInstance()->getString("NewFolderID"); +char const* const _PREHASH_Arc = LLMessageStringTable::getInstance()->getString("Arc"); +char const* const _PREHASH_RegionX = LLMessageStringTable::getInstance()->getString("RegionX"); +char const* const _PREHASH_RegionY = LLMessageStringTable::getInstance()->getString("RegionY"); +char const* const _PREHASH_RequestData = LLMessageStringTable::getInstance()->getString("RequestData"); +char const* const _PREHASH_Msg = LLMessageStringTable::getInstance()->getString("Msg"); +char const* const _PREHASH_Top = LLMessageStringTable::getInstance()->getString("Top"); +char const* const _PREHASH_MiscStats = LLMessageStringTable::getInstance()->getString("MiscStats"); +char const* const _PREHASH_ImageID = LLMessageStringTable::getInstance()->getString("ImageID"); +char const* const _PREHASH_DataPacket = LLMessageStringTable::getInstance()->getString("DataPacket"); +char const* const _PREHASH_You = LLMessageStringTable::getInstance()->getString("You"); +char const* const _PREHASH_ScriptControlChange = LLMessageStringTable::getInstance()->getString("ScriptControlChange"); +char const* const _PREHASH_LoadURL = LLMessageStringTable::getInstance()->getString("LoadURL"); +char const* const _PREHASH_SetCPURatio = LLMessageStringTable::getInstance()->getString("SetCPURatio"); +char const* const _PREHASH_NameValueData = LLMessageStringTable::getInstance()->getString("NameValueData"); +char const* const _PREHASH_AtomicPassObject = LLMessageStringTable::getInstance()->getString("AtomicPassObject"); +char const* const _PREHASH_ErrorMessage = LLMessageStringTable::getInstance()->getString("ErrorMessage"); +char const* const _PREHASH_ViewerFrozenMessage = LLMessageStringTable::getInstance()->getString("ViewerFrozenMessage"); +char const* const _PREHASH_HealthMessage = LLMessageStringTable::getInstance()->getString("HealthMessage"); +char const* const _PREHASH_LogTextMessage = LLMessageStringTable::getInstance()->getString("LogTextMessage"); +char const* const _PREHASH_TimeDilation = LLMessageStringTable::getInstance()->getString("TimeDilation"); +char const* const _PREHASH_RemoveContribution = LLMessageStringTable::getInstance()->getString("RemoveContribution"); +char const* const _PREHASH_Contribution = LLMessageStringTable::getInstance()->getString("Contribution"); +char const* const _PREHASH_SetGroupContribution = LLMessageStringTable::getInstance()->getString("SetGroupContribution"); +char const* const _PREHASH_Offline = LLMessageStringTable::getInstance()->getString("Offline"); +char const* const _PREHASH_AgentIsNowWearing = LLMessageStringTable::getInstance()->getString("AgentIsNowWearing"); +char const* const _PREHASH_Members = LLMessageStringTable::getInstance()->getString("Members"); +char const* const _PREHASH_FailedResends = LLMessageStringTable::getInstance()->getString("FailedResends"); +char const* const _PREHASH_SecPerDay = LLMessageStringTable::getInstance()->getString("SecPerDay"); +char const* const _PREHASH_CameraCenter = LLMessageStringTable::getInstance()->getString("CameraCenter"); +char const* const _PREHASH_CameraLeftAxis = LLMessageStringTable::getInstance()->getString("CameraLeftAxis"); +char const* const _PREHASH_ExBlock = LLMessageStringTable::getInstance()->getString("ExBlock"); +char const* const _PREHASH_Channel = LLMessageStringTable::getInstance()->getString("Channel"); +char const* const _PREHASH_NetTest = LLMessageStringTable::getInstance()->getString("NetTest"); +char const* const _PREHASH_DiscardLevel = LLMessageStringTable::getInstance()->getString("DiscardLevel"); +char const* const _PREHASH_LayerID = LLMessageStringTable::getInstance()->getString("LayerID"); +char const* const _PREHASH_GrabOffset = LLMessageStringTable::getInstance()->getString("GrabOffset"); +char const* const _PREHASH_SimPort = LLMessageStringTable::getInstance()->getString("SimPort"); +char const* const _PREHASH_PricePerMeter = LLMessageStringTable::getInstance()->getString("PricePerMeter"); +char const* const _PREHASH_RegionFlags = LLMessageStringTable::getInstance()->getString("RegionFlags"); +char const* const _PREHASH_VoteResult = LLMessageStringTable::getInstance()->getString("VoteResult"); +char const* const _PREHASH_ParcelDirFeeEstimate = LLMessageStringTable::getInstance()->getString("ParcelDirFeeEstimate"); +char const* const _PREHASH_ModifyBlock = LLMessageStringTable::getInstance()->getString("ModifyBlock"); +char const* const _PREHASH_InventoryBlock = LLMessageStringTable::getInstance()->getString("InventoryBlock"); +char const* const _PREHASH_ReplyBlock = LLMessageStringTable::getInstance()->getString("ReplyBlock"); +char const* const _PREHASH_ValidUntil = LLMessageStringTable::getInstance()->getString("ValidUntil"); +char const* const _PREHASH_VelocityInterpolateOn = LLMessageStringTable::getInstance()->getString("VelocityInterpolateOn"); +char const* const _PREHASH_ClassifiedDelete = LLMessageStringTable::getInstance()->getString("ClassifiedDelete"); +char const* const _PREHASH_RegionDenyAnonymous = LLMessageStringTable::getInstance()->getString("RegionDenyAnonymous"); +char const* const _PREHASH_FLImageID = LLMessageStringTable::getInstance()->getString("FLImageID"); +char const* const _PREHASH_AllowPublish = LLMessageStringTable::getInstance()->getString("AllowPublish"); +char const* const _PREHASH_SitName = LLMessageStringTable::getInstance()->getString("SitName"); +char const* const _PREHASH_RegionsVisited = LLMessageStringTable::getInstance()->getString("RegionsVisited"); +char const* const _PREHASH_DirClassifiedReply = LLMessageStringTable::getInstance()->getString("DirClassifiedReply"); +char const* const _PREHASH_AvatarClassifiedReply = LLMessageStringTable::getInstance()->getString("AvatarClassifiedReply"); +char const* const _PREHASH_MediaURL = LLMessageStringTable::getInstance()->getString("MediaURL"); +char const* const _PREHASH_CompleteAgentMovement = LLMessageStringTable::getInstance()->getString("CompleteAgentMovement"); +char const* const _PREHASH_ClassifiedID = LLMessageStringTable::getInstance()->getString("ClassifiedID"); +char const* const _PREHASH_LocalID = LLMessageStringTable::getInstance()->getString("LocalID"); +char const* const _PREHASH_SpaceIP = LLMessageStringTable::getInstance()->getString("SpaceIP"); +char const* const _PREHASH_RemoveItem = LLMessageStringTable::getInstance()->getString("RemoveItem"); +char const* const _PREHASH_LogFailedMoneyTransaction = LLMessageStringTable::getInstance()->getString("LogFailedMoneyTransaction"); +char const* const _PREHASH_ViewerStartAuction = LLMessageStringTable::getInstance()->getString("ViewerStartAuction"); +char const* const _PREHASH_StartAuction = LLMessageStringTable::getInstance()->getString("StartAuction"); +char const* const _PREHASH_DuplicateFlags = LLMessageStringTable::getInstance()->getString("DuplicateFlags"); +char const* const _PREHASH_RegionInfo2 = LLMessageStringTable::getInstance()->getString("RegionInfo2"); +char const* const _PREHASH_TextColor = LLMessageStringTable::getInstance()->getString("TextColor"); +char const* const _PREHASH_SlaveID = LLMessageStringTable::getInstance()->getString("SlaveID"); +char const* const _PREHASH_Charter = LLMessageStringTable::getInstance()->getString("Charter"); +char const* const _PREHASH_AlertData = LLMessageStringTable::getInstance()->getString("AlertData"); +char const* const _PREHASH_AlertInfo = LLMessageStringTable::getInstance()->getString("AlertInfo"); +char const* const _PREHASH_TargetBlock = LLMessageStringTable::getInstance()->getString("TargetBlock"); +char const* const _PREHASH_CheckParcelAuctions = LLMessageStringTable::getInstance()->getString("CheckParcelAuctions"); +char const* const _PREHASH_ParcelAuctions = LLMessageStringTable::getInstance()->getString("ParcelAuctions"); +char const* const _PREHASH_OwnerIsGroup = LLMessageStringTable::getInstance()->getString("OwnerIsGroup"); +char const* const _PREHASH_NameValuePair = LLMessageStringTable::getInstance()->getString("NameValuePair"); +char const* const _PREHASH_RemoveNameValuePair = LLMessageStringTable::getInstance()->getString("RemoveNameValuePair"); +char const* const _PREHASH_BulkUpdateInventory = LLMessageStringTable::getInstance()->getString("BulkUpdateInventory"); +char const* const _PREHASH_UpdateTaskInventory = LLMessageStringTable::getInstance()->getString("UpdateTaskInventory"); +char const* const _PREHASH_RemoveTaskInventory = LLMessageStringTable::getInstance()->getString("RemoveTaskInventory"); +char const* const _PREHASH_MoveTaskInventory = LLMessageStringTable::getInstance()->getString("MoveTaskInventory"); +char const* const _PREHASH_RequestTaskInventory = LLMessageStringTable::getInstance()->getString("RequestTaskInventory"); +char const* const _PREHASH_ReplyTaskInventory = LLMessageStringTable::getInstance()->getString("ReplyTaskInventory"); +char const* const _PREHASH_AggregatePermInventory = LLMessageStringTable::getInstance()->getString("AggregatePermInventory"); +char const* const _PREHASH_GroupAccountTransactionsReply = LLMessageStringTable::getInstance()->getString("GroupAccountTransactionsReply"); +char const* const _PREHASH_SimulatorInfo = LLMessageStringTable::getInstance()->getString("SimulatorInfo"); +char const* const _PREHASH_WearableData = LLMessageStringTable::getInstance()->getString("WearableData"); +char const* const _PREHASH_Enabled = LLMessageStringTable::getInstance()->getString("Enabled"); +char const* const _PREHASH_Savings = LLMessageStringTable::getInstance()->getString("Savings"); +char const* const _PREHASH_SimulatorLoad = LLMessageStringTable::getInstance()->getString("SimulatorLoad"); +char const* const _PREHASH_InternalRegionIP = LLMessageStringTable::getInstance()->getString("InternalRegionIP"); +char const* const _PREHASH_ExternalRegionIP = LLMessageStringTable::getInstance()->getString("ExternalRegionIP"); +char const* const _PREHASH_TotalPairs = LLMessageStringTable::getInstance()->getString("TotalPairs"); +char const* const _PREHASH_CreateGroupRequest = LLMessageStringTable::getInstance()->getString("CreateGroupRequest"); +char const* const _PREHASH_JoinGroupRequest = LLMessageStringTable::getInstance()->getString("JoinGroupRequest"); +char const* const _PREHASH_LeaveGroupRequest = LLMessageStringTable::getInstance()->getString("LeaveGroupRequest"); +char const* const _PREHASH_InviteGroupRequest = LLMessageStringTable::getInstance()->getString("InviteGroupRequest"); +char const* const _PREHASH_LiveHelpGroupRequest = LLMessageStringTable::getInstance()->getString("LiveHelpGroupRequest"); +char const* const _PREHASH_PriceParcelClaimFactor = LLMessageStringTable::getInstance()->getString("PriceParcelClaimFactor"); +char const* const _PREHASH_BillableArea = LLMessageStringTable::getInstance()->getString("BillableArea"); +char const* const _PREHASH_ObjectID = LLMessageStringTable::getInstance()->getString("ObjectID"); +char const* const _PREHASH_ObjectFlagUpdate = LLMessageStringTable::getInstance()->getString("ObjectFlagUpdate"); +char const* const _PREHASH_GroupRoleUpdate = LLMessageStringTable::getInstance()->getString("GroupRoleUpdate"); +char const* const _PREHASH_RequestInventoryAsset = LLMessageStringTable::getInstance()->getString("RequestInventoryAsset"); +char const* const _PREHASH_ChangedGrid = LLMessageStringTable::getInstance()->getString("ChangedGrid"); +char const* const _PREHASH_AgentDropGroup = LLMessageStringTable::getInstance()->getString("AgentDropGroup"); +char const* const _PREHASH_Details = LLMessageStringTable::getInstance()->getString("Details"); +char const* const _PREHASH_LocationX = LLMessageStringTable::getInstance()->getString("LocationX"); +char const* const _PREHASH_SaleType = LLMessageStringTable::getInstance()->getString("SaleType"); +char const* const _PREHASH_LocationY = LLMessageStringTable::getInstance()->getString("LocationY"); +char const* const _PREHASH_LocationZ = LLMessageStringTable::getInstance()->getString("LocationZ"); +char const* const _PREHASH_EconomyData = LLMessageStringTable::getInstance()->getString("EconomyData"); +char const* const _PREHASH_HeadRotation = LLMessageStringTable::getInstance()->getString("HeadRotation"); +char const* const _PREHASH_DeleteOnCompletion = LLMessageStringTable::getInstance()->getString("DeleteOnCompletion"); +char const* const _PREHASH_PublicPort = LLMessageStringTable::getInstance()->getString("PublicPort"); +char const* const _PREHASH_DirClassifiedQuery = LLMessageStringTable::getInstance()->getString("DirClassifiedQuery"); +char const* const _PREHASH_CallbackID = LLMessageStringTable::getInstance()->getString("CallbackID"); +char const* const _PREHASH_RequestParcelTransfer = LLMessageStringTable::getInstance()->getString("RequestParcelTransfer"); +char const* const _PREHASH_RoleCount = LLMessageStringTable::getInstance()->getString("RoleCount"); +char const* const _PREHASH_ObjectCapacity = LLMessageStringTable::getInstance()->getString("ObjectCapacity"); +char const* const _PREHASH_RequestID = LLMessageStringTable::getInstance()->getString("RequestID"); +char const* const _PREHASH_RequestXfer = LLMessageStringTable::getInstance()->getString("RequestXfer"); +char const* const _PREHASH_ObjectTaxCurrent = LLMessageStringTable::getInstance()->getString("ObjectTaxCurrent"); +char const* const _PREHASH_LightTaxCurrent = LLMessageStringTable::getInstance()->getString("LightTaxCurrent"); +char const* const _PREHASH_LandTaxCurrent = LLMessageStringTable::getInstance()->getString("LandTaxCurrent"); +char const* const _PREHASH_GroupTaxCurrent = LLMessageStringTable::getInstance()->getString("GroupTaxCurrent"); +char const* const _PREHASH_FetchInventoryDescendents = LLMessageStringTable::getInstance()->getString("FetchInventoryDescendents"); +char const* const _PREHASH_InventoryDescendents = LLMessageStringTable::getInstance()->getString("InventoryDescendents"); +char const* const _PREHASH_Descendents = LLMessageStringTable::getInstance()->getString("Descendents"); +char const* const _PREHASH_PurgeInventoryDescendents = LLMessageStringTable::getInstance()->getString("PurgeInventoryDescendents"); +char const* const _PREHASH_ShowDir = LLMessageStringTable::getInstance()->getString("ShowDir"); +char const* const _PREHASH_IsOwner = LLMessageStringTable::getInstance()->getString("IsOwner"); +char const* const _PREHASH_Timestamp = LLMessageStringTable::getInstance()->getString("Timestamp"); +char const* const _PREHASH_GlobalPos = LLMessageStringTable::getInstance()->getString("GlobalPos"); +char const* const _PREHASH_GrabOffsetInitial = LLMessageStringTable::getInstance()->getString("GrabOffsetInitial"); +char const* const _PREHASH_IsTrial = LLMessageStringTable::getInstance()->getString("IsTrial"); +char const* const _PREHASH_ObjectDuplicateOnRay = LLMessageStringTable::getInstance()->getString("ObjectDuplicateOnRay"); +char const* const _PREHASH_GroupMembershipCount = LLMessageStringTable::getInstance()->getString("GroupMembershipCount"); +char const* const _PREHASH_MethodData = LLMessageStringTable::getInstance()->getString("MethodData"); +char const* const _PREHASH_ActivateGestures = LLMessageStringTable::getInstance()->getString("ActivateGestures"); +char const* const _PREHASH_DeactivateGestures = LLMessageStringTable::getInstance()->getString("DeactivateGestures"); +char const* const _PREHASH_ProposalData = LLMessageStringTable::getInstance()->getString("ProposalData"); +char const* const _PREHASH_PosGlobal = LLMessageStringTable::getInstance()->getString("PosGlobal"); +char const* const _PREHASH_SearchID = LLMessageStringTable::getInstance()->getString("SearchID"); +char const* const _PREHASH_RezMultipleAttachmentsFromInv = LLMessageStringTable::getInstance()->getString("RezMultipleAttachmentsFromInv"); +char const* const _PREHASH_SearchName = LLMessageStringTable::getInstance()->getString("SearchName"); +char const* const _PREHASH_VersionString = LLMessageStringTable::getInstance()->getString("VersionString"); +char const* const _PREHASH_CreateGroupReply = LLMessageStringTable::getInstance()->getString("CreateGroupReply"); +char const* const _PREHASH_LeaveGroupReply = LLMessageStringTable::getInstance()->getString("LeaveGroupReply"); +char const* const _PREHASH_ActualArea = LLMessageStringTable::getInstance()->getString("ActualArea"); +char const* const _PREHASH_Message = LLMessageStringTable::getInstance()->getString("Message"); +char const* const _PREHASH_ClickAction = LLMessageStringTable::getInstance()->getString("ClickAction"); +char const* const _PREHASH_AssetUploadComplete = LLMessageStringTable::getInstance()->getString("AssetUploadComplete"); +char const* const _PREHASH_RequestType = LLMessageStringTable::getInstance()->getString("RequestType"); +char const* const _PREHASH_UUID = LLMessageStringTable::getInstance()->getString("UUID"); +char const* const _PREHASH_BaseMask = LLMessageStringTable::getInstance()->getString("BaseMask"); +char const* const _PREHASH_NetBlock = LLMessageStringTable::getInstance()->getString("NetBlock"); +char const* const _PREHASH_GlobalX = LLMessageStringTable::getInstance()->getString("GlobalX"); +char const* const _PREHASH_GlobalY = LLMessageStringTable::getInstance()->getString("GlobalY"); +char const* const _PREHASH_CopyRotates = LLMessageStringTable::getInstance()->getString("CopyRotates"); +char const* const _PREHASH_KickUserAck = LLMessageStringTable::getInstance()->getString("KickUserAck"); +char const* const _PREHASH_TopPick = LLMessageStringTable::getInstance()->getString("TopPick"); //legacy var need to be deleted -angela +char const* const _PREHASH_SessionID = LLMessageStringTable::getInstance()->getString("SessionID"); +char const* const _PREHASH_GlobalZ = LLMessageStringTable::getInstance()->getString("GlobalZ"); +char const* const _PREHASH_DeclineFriendship = LLMessageStringTable::getInstance()->getString("DeclineFriendship"); +char const* const _PREHASH_FormFriendship = LLMessageStringTable::getInstance()->getString("FormFriendship"); +char const* const _PREHASH_TerminateFriendship = LLMessageStringTable::getInstance()->getString("TerminateFriendship"); +char const* const _PREHASH_TaskData = LLMessageStringTable::getInstance()->getString("TaskData"); +char const* const _PREHASH_SimWideMaxPrims = LLMessageStringTable::getInstance()->getString("SimWideMaxPrims"); +char const* const _PREHASH_TotalPrims = LLMessageStringTable::getInstance()->getString("TotalPrims"); +char const* const _PREHASH_ProfileBegin = LLMessageStringTable::getInstance()->getString("ProfileBegin"); +char const* const _PREHASH_Request = LLMessageStringTable::getInstance()->getString("Request"); +char const* const _PREHASH_GroupAccountDetailsRequest = LLMessageStringTable::getInstance()->getString("GroupAccountDetailsRequest"); +char const* const _PREHASH_GroupActiveProposalsRequest = LLMessageStringTable::getInstance()->getString("GroupActiveProposalsRequest"); +char const* const _PREHASH_StringValue = LLMessageStringTable::getInstance()->getString("StringValue"); +char const* const _PREHASH_Version = LLMessageStringTable::getInstance()->getString("Version"); +char const* const _PREHASH_OtherCount = LLMessageStringTable::getInstance()->getString("OtherCount"); +char const* const _PREHASH_MemberCount = LLMessageStringTable::getInstance()->getString("MemberCount"); +char const* const _PREHASH_ChatData = LLMessageStringTable::getInstance()->getString("ChatData"); +char const* const _PREHASH_IsGroupOwned = LLMessageStringTable::getInstance()->getString("IsGroupOwned"); +char const* const _PREHASH_EnergyEfficiency = LLMessageStringTable::getInstance()->getString("EnergyEfficiency"); +char const* const _PREHASH_PickInfoUpdate = LLMessageStringTable::getInstance()->getString("PickInfoUpdate"); +char const* const _PREHASH_PickDelete = LLMessageStringTable::getInstance()->getString("PickDelete"); +char const* const _PREHASH_ScriptReset = LLMessageStringTable::getInstance()->getString("ScriptReset"); +char const* const _PREHASH_Requester = LLMessageStringTable::getInstance()->getString("Requester"); +char const* const _PREHASH_ForSale = LLMessageStringTable::getInstance()->getString("ForSale"); +char const* const _PREHASH_NearestLandingRegionReply = LLMessageStringTable::getInstance()->getString("NearestLandingRegionReply"); +char const* const _PREHASH_ParcelID = LLMessageStringTable::getInstance()->getString("ParcelID"); +char const* const _PREHASH_Godlike = LLMessageStringTable::getInstance()->getString("Godlike"); +char const* const _PREHASH_TotalDebits = LLMessageStringTable::getInstance()->getString("TotalDebits"); +char const* const _PREHASH_Direction = LLMessageStringTable::getInstance()->getString("Direction"); +char const* const _PREHASH_HealthData = LLMessageStringTable::getInstance()->getString("HealthData"); +char const* const _PREHASH_LeftAxis = LLMessageStringTable::getInstance()->getString("LeftAxis"); +char const* const _PREHASH_LocationBlock = LLMessageStringTable::getInstance()->getString("LocationBlock"); +char const* const _PREHASH_ObjectImage = LLMessageStringTable::getInstance()->getString("ObjectImage"); +char const* const _PREHASH_TerrainStartHeight00 = LLMessageStringTable::getInstance()->getString("TerrainStartHeight00"); +char const* const _PREHASH_TerrainStartHeight01 = LLMessageStringTable::getInstance()->getString("TerrainStartHeight01"); +char const* const _PREHASH_TerrainStartHeight10 = LLMessageStringTable::getInstance()->getString("TerrainStartHeight10"); +char const* const _PREHASH_TerrainStartHeight11 = LLMessageStringTable::getInstance()->getString("TerrainStartHeight11"); +char const* const _PREHASH_WaterHeight = LLMessageStringTable::getInstance()->getString("WaterHeight"); +char const* const _PREHASH_FetchInventoryReply = LLMessageStringTable::getInstance()->getString("FetchInventoryReply"); +char const* const _PREHASH_GroupAccountSummaryReply = LLMessageStringTable::getInstance()->getString("GroupAccountSummaryReply"); +char const* const _PREHASH_AttachedSound = LLMessageStringTable::getInstance()->getString("AttachedSound"); +char const* const _PREHASH_ParamInUse = LLMessageStringTable::getInstance()->getString("ParamInUse"); +char const* const _PREHASH_GodKickUser = LLMessageStringTable::getInstance()->getString("GodKickUser"); +char const* const _PREHASH_PickName = LLMessageStringTable::getInstance()->getString("PickName"); +char const* const _PREHASH_TaskName = LLMessageStringTable::getInstance()->getString("TaskName"); +char const* const _PREHASH_ObjectCount = LLMessageStringTable::getInstance()->getString("ObjectCount"); +char const* const _PREHASH_RegionPresenceRequestByHandle = LLMessageStringTable::getInstance()->getString("RegionPresenceRequestByHandle"); +char const* const _PREHASH_RezSingleAttachmentFromInv = LLMessageStringTable::getInstance()->getString("RezSingleAttachmentFromInv"); +char const* const _PREHASH_ChildAgentUpdate = LLMessageStringTable::getInstance()->getString("ChildAgentUpdate"); +char const* const _PREHASH_IsOwnerGroup = LLMessageStringTable::getInstance()->getString("IsOwnerGroup"); +char const* const _PREHASH_AgentHeightWidth = LLMessageStringTable::getInstance()->getString("AgentHeightWidth"); +char const* const _PREHASH_VerticalAngle = LLMessageStringTable::getInstance()->getString("VerticalAngle"); +char const* const _PREHASH_WearableType = LLMessageStringTable::getInstance()->getString("WearableType"); +char const* const _PREHASH_AggregatePermNextOwner = LLMessageStringTable::getInstance()->getString("AggregatePermNextOwner"); +char const* const _PREHASH_ShowInList = LLMessageStringTable::getInstance()->getString("ShowInList"); +char const* const _PREHASH_UpdateParcel = LLMessageStringTable::getInstance()->getString("UpdateParcel"); +char const* const _PREHASH_SetAlwaysRun = LLMessageStringTable::getInstance()->getString("SetAlwaysRun"); +char const* const _PREHASH_NVPair = LLMessageStringTable::getInstance()->getString("NVPair"); +char const* const _PREHASH_SearchType = LLMessageStringTable::getInstance()->getString("SearchType"); +char const* const _PREHASH_ObjectSpinStart = LLMessageStringTable::getInstance()->getString("ObjectSpinStart"); +char const* const _PREHASH_UseEstateSun = LLMessageStringTable::getInstance()->getString("UseEstateSun"); +char const* const _PREHASH_RegionID = LLMessageStringTable::getInstance()->getString("RegionID"); +char const* const _PREHASH_AbuseRegionID = LLMessageStringTable::getInstance()->getString("AbuseRegionID"); +char const* const _PREHASH_Creator = LLMessageStringTable::getInstance()->getString("Creator"); +char const* const _PREHASH_ProposalText = LLMessageStringTable::getInstance()->getString("ProposalText"); +char const* const _PREHASH_DirEventsReply = LLMessageStringTable::getInstance()->getString("DirEventsReply"); +char const* const _PREHASH_EventInfoReply = LLMessageStringTable::getInstance()->getString("EventInfoReply"); +char const* const _PREHASH_UserInfoReply = LLMessageStringTable::getInstance()->getString("UserInfoReply"); +char const* const _PREHASH_PathRadiusOffset = LLMessageStringTable::getInstance()->getString("PathRadiusOffset"); +char const* const _PREHASH_TextureData = LLMessageStringTable::getInstance()->getString("TextureData"); +char const* const _PREHASH_ChatPass = LLMessageStringTable::getInstance()->getString("ChatPass"); +char const* const _PREHASH_TargetID = LLMessageStringTable::getInstance()->getString("TargetID"); +char const* const _PREHASH_DefaultPayPrice = LLMessageStringTable::getInstance()->getString("DefaultPayPrice"); +char const* const _PREHASH_UserLocation = LLMessageStringTable::getInstance()->getString("UserLocation"); +char const* const _PREHASH_MaxPrims = LLMessageStringTable::getInstance()->getString("MaxPrims"); +char const* const _PREHASH_LandmarkID = LLMessageStringTable::getInstance()->getString("LandmarkID"); +char const* const _PREHASH_InitiateDownload = LLMessageStringTable::getInstance()->getString("InitiateDownload"); +char const* const _PREHASH_Name = LLMessageStringTable::getInstance()->getString("Name"); +char const* const _PREHASH_OtherCleanTime = LLMessageStringTable::getInstance()->getString("OtherCleanTime"); +char const* const _PREHASH_ParcelSetOtherCleanTime = LLMessageStringTable::getInstance()->getString("ParcelSetOtherCleanTime"); +char const* const _PREHASH_TeleportPriceExponent = LLMessageStringTable::getInstance()->getString("TeleportPriceExponent"); +char const* const _PREHASH_Gain = LLMessageStringTable::getInstance()->getString("Gain"); +char const* const _PREHASH_PacketAck = LLMessageStringTable::getInstance()->getString("PacketAck"); +char const* const _PREHASH_PathSkew = LLMessageStringTable::getInstance()->getString("PathSkew"); +char const* const _PREHASH_SimulatorShutdownRequest = LLMessageStringTable::getInstance()->getString("SimulatorShutdownRequest"); +char const* const _PREHASH_NearestLandingRegionRequest = LLMessageStringTable::getInstance()->getString("NearestLandingRegionRequest"); +char const* const _PREHASH_OtherID = LLMessageStringTable::getInstance()->getString("OtherID"); +char const* const _PREHASH_MemberID = LLMessageStringTable::getInstance()->getString("MemberID"); +char const* const _PREHASH_MapLayerRequest = LLMessageStringTable::getInstance()->getString("MapLayerRequest"); +char const* const _PREHASH_ObjectScale = LLMessageStringTable::getInstance()->getString("ObjectScale"); +char const* const _PREHASH_TargetIP = LLMessageStringTable::getInstance()->getString("TargetIP"); +char const* const _PREHASH_Redo = LLMessageStringTable::getInstance()->getString("Redo"); +char const* const _PREHASH_MoneyBalance = LLMessageStringTable::getInstance()->getString("MoneyBalance"); +char const* const _PREHASH_TrackAgent = LLMessageStringTable::getInstance()->getString("TrackAgent"); +char const* const _PREHASH_MaxX = LLMessageStringTable::getInstance()->getString("MaxX"); +char const* const _PREHASH_Data = LLMessageStringTable::getInstance()->getString("Data"); +char const* const _PREHASH_MaxY = LLMessageStringTable::getInstance()->getString("MaxY"); +char const* const _PREHASH_TextureAnim = LLMessageStringTable::getInstance()->getString("TextureAnim"); +char const* const _PREHASH_ReturnIDs = LLMessageStringTable::getInstance()->getString("ReturnIDs"); +char const* const _PREHASH_Date = LLMessageStringTable::getInstance()->getString("Date"); +char const* const _PREHASH_AgentWearablesUpdate = LLMessageStringTable::getInstance()->getString("AgentWearablesUpdate"); +char const* const _PREHASH_AgentDataUpdate = LLMessageStringTable::getInstance()->getString("AgentDataUpdate"); +char const* const _PREHASH_GroupDataUpdate = LLMessageStringTable::getInstance()->getString("GroupDataUpdate"); +char const* const _PREHASH_Hash = LLMessageStringTable::getInstance()->getString("Hash"); +char const* const _PREHASH_AgentGroupDataUpdate = LLMessageStringTable::getInstance()->getString("AgentGroupDataUpdate"); +char const* const _PREHASH_Left = LLMessageStringTable::getInstance()->getString("Left"); +char const* const _PREHASH_Mask = LLMessageStringTable::getInstance()->getString("Mask"); +char const* const _PREHASH_ForceMouselook = LLMessageStringTable::getInstance()->getString("ForceMouselook"); +char const* const _PREHASH_Success = LLMessageStringTable::getInstance()->getString("Success"); +char const* const _PREHASH_ObjectGroup = LLMessageStringTable::getInstance()->getString("ObjectGroup"); +char const* const _PREHASH_SunHour = LLMessageStringTable::getInstance()->getString("SunHour"); +char const* const _PREHASH_MinX = LLMessageStringTable::getInstance()->getString("MinX"); +char const* const _PREHASH_ScriptSensorReply = LLMessageStringTable::getInstance()->getString("ScriptSensorReply"); +char const* const _PREHASH_MinY = LLMessageStringTable::getInstance()->getString("MinY"); +char const* const _PREHASH_Command = LLMessageStringTable::getInstance()->getString("Command"); +char const* const _PREHASH_Desc = LLMessageStringTable::getInstance()->getString("Desc"); +char const* const _PREHASH_AttachmentNeedsSave = LLMessageStringTable::getInstance()->getString("AttachmentNeedsSave"); +char const* const _PREHASH_HistoryItemData = LLMessageStringTable::getInstance()->getString("HistoryItemData"); +char const* const _PREHASH_AgentCachedTexture = LLMessageStringTable::getInstance()->getString("AgentCachedTexture"); +char const* const _PREHASH_Subject = LLMessageStringTable::getInstance()->getString("Subject"); +char const* const _PREHASH_East = LLMessageStringTable::getInstance()->getString("East"); +char const* const _PREHASH_QueryReplies = LLMessageStringTable::getInstance()->getString("QueryReplies"); +char const* const _PREHASH_ObjectCategory = LLMessageStringTable::getInstance()->getString("ObjectCategory"); +char const* const _PREHASH_Time = LLMessageStringTable::getInstance()->getString("Time"); +char const* const _PREHASH_CreateLandmarkForEvent = LLMessageStringTable::getInstance()->getString("CreateLandmarkForEvent"); +char const* const _PREHASH_ParentID = LLMessageStringTable::getInstance()->getString("ParentID"); +char const* const _PREHASH_Ping = LLMessageStringTable::getInstance()->getString("Ping"); +char const* const _PREHASH_Perp = LLMessageStringTable::getInstance()->getString("Perp"); +char const* const _PREHASH_Code = LLMessageStringTable::getInstance()->getString("Code"); +char const* const _PREHASH_InvType = LLMessageStringTable::getInstance()->getString("InvType"); +char const* const _PREHASH_AgentFOV = LLMessageStringTable::getInstance()->getString("AgentFOV"); +char const* const _PREHASH_Audible = LLMessageStringTable::getInstance()->getString("Audible"); +char const* const _PREHASH_AuctionData = LLMessageStringTable::getInstance()->getString("AuctionData"); +char const* const _PREHASH_IDBlock = LLMessageStringTable::getInstance()->getString("IDBlock"); +char const* const _PREHASH_West = LLMessageStringTable::getInstance()->getString("West"); +char const* const _PREHASH_Undo = LLMessageStringTable::getInstance()->getString("Undo"); +char const* const _PREHASH_TotalNumItems = LLMessageStringTable::getInstance()->getString("TotalNumItems"); +char const* const _PREHASH_Info = LLMessageStringTable::getInstance()->getString("Info"); +char const* const _PREHASH_Area = LLMessageStringTable::getInstance()->getString("Area"); +char const* const _PREHASH_SimCrashed = LLMessageStringTable::getInstance()->getString("SimCrashed"); +char const* const _PREHASH_Text = LLMessageStringTable::getInstance()->getString("Text"); +char const* const _PREHASH_PriceGroupCreate = LLMessageStringTable::getInstance()->getString("PriceGroupCreate"); +char const* const _PREHASH_ObjectShape = LLMessageStringTable::getInstance()->getString("ObjectShape"); +char const* const _PREHASH_GroupRoleDataReply = LLMessageStringTable::getInstance()->getString("GroupRoleDataReply"); +char const* const _PREHASH_MuteCRC = LLMessageStringTable::getInstance()->getString("MuteCRC"); +char const* const _PREHASH_Size = LLMessageStringTable::getInstance()->getString("Size"); +char const* const _PREHASH_FromAddress = LLMessageStringTable::getInstance()->getString("FromAddress"); +char const* const _PREHASH_Body = LLMessageStringTable::getInstance()->getString("Body"); +char const* const _PREHASH_FileData = LLMessageStringTable::getInstance()->getString("FileData"); +char const* const _PREHASH_List = LLMessageStringTable::getInstance()->getString("List"); +char const* const _PREHASH_KickUser = LLMessageStringTable::getInstance()->getString("KickUser"); +char const* const _PREHASH_OtherPrims = LLMessageStringTable::getInstance()->getString("OtherPrims"); +char const* const _PREHASH_RunTime = LLMessageStringTable::getInstance()->getString("RunTime"); +char const* const _PREHASH_GrantUserRights = LLMessageStringTable::getInstance()->getString("GrantUserRights"); +char const* const _PREHASH_RpcScriptRequestInboundForward = LLMessageStringTable::getInstance()->getString("RpcScriptRequestInboundForward"); +char const* const _PREHASH_More = LLMessageStringTable::getInstance()->getString("More"); +char const* const _PREHASH_Majority = LLMessageStringTable::getInstance()->getString("Majority"); +char const* const _PREHASH_MetersTraveled = LLMessageStringTable::getInstance()->getString("MetersTraveled"); +char const* const _PREHASH_Stat = LLMessageStringTable::getInstance()->getString("Stat"); +char const* const _PREHASH_SoundID = LLMessageStringTable::getInstance()->getString("SoundID"); +char const* const _PREHASH_Item = LLMessageStringTable::getInstance()->getString("Item"); +char const* const _PREHASH_User = LLMessageStringTable::getInstance()->getString("User"); +char const* const _PREHASH_Prey = LLMessageStringTable::getInstance()->getString("Prey"); +char const* const _PREHASH_RayStart = LLMessageStringTable::getInstance()->getString("RayStart"); +char const* const _PREHASH_UsecSinceStart = LLMessageStringTable::getInstance()->getString("UsecSinceStart"); +char const* const _PREHASH_ParcelData = LLMessageStringTable::getInstance()->getString("ParcelData"); +char const* const _PREHASH_CameraUpAxis = LLMessageStringTable::getInstance()->getString("CameraUpAxis"); +char const* const _PREHASH_ScriptDialog = LLMessageStringTable::getInstance()->getString("ScriptDialog"); +char const* const _PREHASH_MasterParcelData = LLMessageStringTable::getInstance()->getString("MasterParcelData"); +char const* const _PREHASH_Invalid = LLMessageStringTable::getInstance()->getString("Invalid"); +char const* const _PREHASH_ProfileCurve = LLMessageStringTable::getInstance()->getString("ProfileCurve"); +char const* const _PREHASH_ParcelAccessListUpdate = LLMessageStringTable::getInstance()->getString("ParcelAccessListUpdate"); +char const* const _PREHASH_MuteListUpdate = LLMessageStringTable::getInstance()->getString("MuteListUpdate"); +char const* const _PREHASH_SendPacket = LLMessageStringTable::getInstance()->getString("SendPacket"); +char const* const _PREHASH_SendXferPacket = LLMessageStringTable::getInstance()->getString("SendXferPacket"); +char const* const _PREHASH_RegionDenyIdentified = LLMessageStringTable::getInstance()->getString("RegionDenyIdentified"); +char const* const _PREHASH_NotecardItemID = LLMessageStringTable::getInstance()->getString("NotecardItemID"); +char const* const _PREHASH_LastName = LLMessageStringTable::getInstance()->getString("LastName"); +char const* const _PREHASH_From = LLMessageStringTable::getInstance()->getString("From"); +char const* const _PREHASH_RoleChange = LLMessageStringTable::getInstance()->getString("RoleChange"); +char const* const _PREHASH_Port = LLMessageStringTable::getInstance()->getString("Port"); +char const* const _PREHASH_MemberTitle = LLMessageStringTable::getInstance()->getString("MemberTitle"); +char const* const _PREHASH_LogParcelChanges = LLMessageStringTable::getInstance()->getString("LogParcelChanges"); +char const* const _PREHASH_AgentCachedTextureResponse = LLMessageStringTable::getInstance()->getString("AgentCachedTextureResponse"); +char const* const _PREHASH_DeRezObject = LLMessageStringTable::getInstance()->getString("DeRezObject"); +char const* const _PREHASH_IsTemporary = LLMessageStringTable::getInstance()->getString("IsTemporary"); +char const* const _PREHASH_InsigniaID = LLMessageStringTable::getInstance()->getString("InsigniaID"); +char const* const _PREHASH_CheckFlags = LLMessageStringTable::getInstance()->getString("CheckFlags"); +char const* const _PREHASH_EventID = LLMessageStringTable::getInstance()->getString("EventID"); +char const* const _PREHASH_Selected = LLMessageStringTable::getInstance()->getString("Selected"); +char const* const _PREHASH_FromAgentId = LLMessageStringTable::getInstance()->getString("FromAgentId"); +char const* const _PREHASH_Type = LLMessageStringTable::getInstance()->getString("Type"); +char const* const _PREHASH_ChatType = LLMessageStringTable::getInstance()->getString("ChatType"); +char const* const _PREHASH_ReportData = LLMessageStringTable::getInstance()->getString("ReportData"); +char const* const _PREHASH_RequestBlock = LLMessageStringTable::getInstance()->getString("RequestBlock"); +char const* const _PREHASH_GrantData = LLMessageStringTable::getInstance()->getString("GrantData"); +char const* const _PREHASH_DetachAttachmentIntoInv = LLMessageStringTable::getInstance()->getString("DetachAttachmentIntoInv"); +char const* const _PREHASH_ParcelDisableObjects = LLMessageStringTable::getInstance()->getString("ParcelDisableObjects"); +char const* const _PREHASH_Sections = LLMessageStringTable::getInstance()->getString("Sections"); +char const* const _PREHASH_GodLevel = LLMessageStringTable::getInstance()->getString("GodLevel"); +char const* const _PREHASH_PayPriceReply = LLMessageStringTable::getInstance()->getString("PayPriceReply"); +char const* const _PREHASH_QueryID = LLMessageStringTable::getInstance()->getString("QueryID"); +char const* const _PREHASH_CameraEyeOffset = LLMessageStringTable::getInstance()->getString("CameraEyeOffset"); +char const* const _PREHASH_AgentPosition = LLMessageStringTable::getInstance()->getString("AgentPosition"); +char const* const _PREHASH_GrabPosition = LLMessageStringTable::getInstance()->getString("GrabPosition"); +char const* const _PREHASH_OnlineNotification = LLMessageStringTable::getInstance()->getString("OnlineNotification"); +char const* const _PREHASH_OfflineNotification = LLMessageStringTable::getInstance()->getString("OfflineNotification"); +char const* const _PREHASH_SendPostcard = LLMessageStringTable::getInstance()->getString("SendPostcard"); +char const* const _PREHASH_RequestFlags = LLMessageStringTable::getInstance()->getString("RequestFlags"); +char const* const _PREHASH_GroupAccountSummaryRequest = LLMessageStringTable::getInstance()->getString("GroupAccountSummaryRequest"); +char const* const _PREHASH_GroupVoteHistoryRequest = LLMessageStringTable::getInstance()->getString("GroupVoteHistoryRequest"); +char const* const _PREHASH_ParamValue = LLMessageStringTable::getInstance()->getString("ParamValue"); +char const* const _PREHASH_MaxAgents = LLMessageStringTable::getInstance()->getString("MaxAgents"); +char const* const _PREHASH_CreateNewOutfitAttachments = LLMessageStringTable::getInstance()->getString("CreateNewOutfitAttachments"); +char const* const _PREHASH_RegionHandle = LLMessageStringTable::getInstance()->getString("RegionHandle"); +char const* const _PREHASH_TeleportProgress = LLMessageStringTable::getInstance()->getString("TeleportProgress"); +char const* const _PREHASH_AgentQuitCopy = LLMessageStringTable::getInstance()->getString("AgentQuitCopy"); +char const* const _PREHASH_AvatarInterestsUpdate = LLMessageStringTable::getInstance()->getString("AvatarInterestsUpdate"); +char const* const _PREHASH_GroupNoticeID = LLMessageStringTable::getInstance()->getString("GroupNoticeID"); +char const* const _PREHASH_ParcelName = LLMessageStringTable::getInstance()->getString("ParcelName"); +char const* const _PREHASH_PriceObjectRent = LLMessageStringTable::getInstance()->getString("PriceObjectRent"); +char const* const _PREHASH_OfferCallingCard = LLMessageStringTable::getInstance()->getString("OfferCallingCard"); +char const* const _PREHASH_AcceptCallingCard = LLMessageStringTable::getInstance()->getString("AcceptCallingCard"); +char const* const _PREHASH_DeclineCallingCard = LLMessageStringTable::getInstance()->getString("DeclineCallingCard"); +char const* const _PREHASH_AgentAccess = LLMessageStringTable::getInstance()->getString("AgentAccess"); +char const* const _PREHASH_AgentLegacyAccess = LLMessageStringTable::getInstance()->getString("AgentLegacyAccess"); +char const* const _PREHASH_AgentMaxAccess = LLMessageStringTable::getInstance()->getString("AgentMaxAccess"); +char const* const _PREHASH_DataHomeLocationReply = LLMessageStringTable::getInstance()->getString("DataHomeLocationReply"); +char const* const _PREHASH_EventLocationReply = LLMessageStringTable::getInstance()->getString("EventLocationReply"); +char const* const _PREHASH_TerseDateID = LLMessageStringTable::getInstance()->getString("TerseDateID"); +char const* const _PREHASH_ObjectOwner = LLMessageStringTable::getInstance()->getString("ObjectOwner"); +char const* const _PREHASH_AssetID = LLMessageStringTable::getInstance()->getString("AssetID"); +char const* const _PREHASH_AlertMessage = LLMessageStringTable::getInstance()->getString("AlertMessage"); +char const* const _PREHASH_AgentAlertMessage = LLMessageStringTable::getInstance()->getString("AgentAlertMessage"); +char const* const _PREHASH_EstateOwnerMessage = LLMessageStringTable::getInstance()->getString("EstateOwnerMessage"); +char const* const _PREHASH_ParcelMediaCommandMessage = LLMessageStringTable::getInstance()->getString("ParcelMediaCommandMessage"); +char const* const _PREHASH_Auction = LLMessageStringTable::getInstance()->getString("Auction"); +char const* const _PREHASH_Category = LLMessageStringTable::getInstance()->getString("Category"); +char const* const _PREHASH_FilePath = LLMessageStringTable::getInstance()->getString("FilePath"); +char const* const _PREHASH_ItemFlags = LLMessageStringTable::getInstance()->getString("ItemFlags"); +char const* const _PREHASH_Invoice = LLMessageStringTable::getInstance()->getString("Invoice"); +char const* const _PREHASH_IntervalDays = LLMessageStringTable::getInstance()->getString("IntervalDays"); +char const* const _PREHASH_PathScaleX = LLMessageStringTable::getInstance()->getString("PathScaleX"); +char const* const _PREHASH_FromTaskID = LLMessageStringTable::getInstance()->getString("FromTaskID"); +char const* const _PREHASH_PathScaleY = LLMessageStringTable::getInstance()->getString("PathScaleY"); +char const* const _PREHASH_TimeInfo = LLMessageStringTable::getInstance()->getString("TimeInfo"); +char const* const _PREHASH_PublicCount = LLMessageStringTable::getInstance()->getString("PublicCount"); +char const* const _PREHASH_ParcelJoin = LLMessageStringTable::getInstance()->getString("ParcelJoin"); +char const* const _PREHASH_GroupRolesCount = LLMessageStringTable::getInstance()->getString("GroupRolesCount"); +char const* const _PREHASH_SimulatorBlock = LLMessageStringTable::getInstance()->getString("SimulatorBlock"); +char const* const _PREHASH_GroupID = LLMessageStringTable::getInstance()->getString("GroupID"); +char const* const _PREHASH_AgentVel = LLMessageStringTable::getInstance()->getString("AgentVel"); +char const* const _PREHASH_RequestImage = LLMessageStringTable::getInstance()->getString("RequestImage"); +char const* const _PREHASH_NetStats = LLMessageStringTable::getInstance()->getString("NetStats"); +char const* const _PREHASH_AgentPos = LLMessageStringTable::getInstance()->getString("AgentPos"); +char const* const _PREHASH_AgentSit = LLMessageStringTable::getInstance()->getString("AgentSit"); +char const* const _PREHASH_Material = LLMessageStringTable::getInstance()->getString("Material"); +char const* const _PREHASH_ObjectDeGrab = LLMessageStringTable::getInstance()->getString("ObjectDeGrab"); +char const* const _PREHASH_VelocityInterpolateOff = LLMessageStringTable::getInstance()->getString("VelocityInterpolateOff"); +char const* const _PREHASH_AuthorizedBuyerID = LLMessageStringTable::getInstance()->getString("AuthorizedBuyerID"); +char const* const _PREHASH_AvatarPropertiesReply = LLMessageStringTable::getInstance()->getString("AvatarPropertiesReply"); +char const* const _PREHASH_GroupProfileReply = LLMessageStringTable::getInstance()->getString("GroupProfileReply"); +char const* const _PREHASH_SimOwner = LLMessageStringTable::getInstance()->getString("SimOwner"); +char const* const _PREHASH_SalePrice = LLMessageStringTable::getInstance()->getString("SalePrice"); +char const* const _PREHASH_Animation = LLMessageStringTable::getInstance()->getString("Animation"); +char const* const _PREHASH_OwnerID = LLMessageStringTable::getInstance()->getString("OwnerID"); +char const* const _PREHASH_NearestLandingRegionUpdated = LLMessageStringTable::getInstance()->getString("NearestLandingRegionUpdated"); +char const* const _PREHASH_PassToAgent = LLMessageStringTable::getInstance()->getString("PassToAgent"); +char const* const _PREHASH_PreyAgent = LLMessageStringTable::getInstance()->getString("PreyAgent"); +char const* const _PREHASH_SimStats = LLMessageStringTable::getInstance()->getString("SimStats"); +char const* const _PREHASH_LogoutReply = LLMessageStringTable::getInstance()->getString("LogoutReply"); +char const* const _PREHASH_FeatureDisabled = LLMessageStringTable::getInstance()->getString("FeatureDisabled"); +char const* const _PREHASH_PhysicalAvatarEventList = LLMessageStringTable::getInstance()->getString("PhysicalAvatarEventList"); +char const* const _PREHASH_ObjectLocalID = LLMessageStringTable::getInstance()->getString("ObjectLocalID"); +char const* const _PREHASH_Dropped = LLMessageStringTable::getInstance()->getString("Dropped"); +char const* const _PREHASH_WebProfilesDisabled = LLMessageStringTable::getInstance()->getString("WebProfilesDisabled"); +char const* const _PREHASH_Destination = LLMessageStringTable::getInstance()->getString("Destination"); +char const* const _PREHASH_MasterID = LLMessageStringTable::getInstance()->getString("MasterID"); +char const* const _PREHASH_TransferData = LLMessageStringTable::getInstance()->getString("TransferData"); +char const* const _PREHASH_WantToMask = LLMessageStringTable::getInstance()->getString("WantToMask"); +char const* const _PREHASH_ParcelSelectObjects = LLMessageStringTable::getInstance()->getString("ParcelSelectObjects"); +char const* const _PREHASH_ExtraParams = LLMessageStringTable::getInstance()->getString("ExtraParams"); +char const* const _PREHASH_CreatorID = LLMessageStringTable::getInstance()->getString("CreatorID"); +char const* const _PREHASH_Summary = LLMessageStringTable::getInstance()->getString("Summary"); +char const* const _PREHASH_BuyObjectInventory = LLMessageStringTable::getInstance()->getString("BuyObjectInventory"); +char const* const _PREHASH_FetchInventory = LLMessageStringTable::getInstance()->getString("FetchInventory"); +char const* const _PREHASH_InventoryID = LLMessageStringTable::getInstance()->getString("InventoryID"); +char const* const _PREHASH_PacketNumber = LLMessageStringTable::getInstance()->getString("PacketNumber"); +char const* const _PREHASH_SetFollowCamProperties = LLMessageStringTable::getInstance()->getString("SetFollowCamProperties"); +char const* const _PREHASH_ClearFollowCamProperties = LLMessageStringTable::getInstance()->getString("ClearFollowCamProperties"); +char const* const _PREHASH_SequenceID = LLMessageStringTable::getInstance()->getString("SequenceID"); +char const* const _PREHASH_DataServerLogout = LLMessageStringTable::getInstance()->getString("DataServerLogout"); +char const* const _PREHASH_NameValue = LLMessageStringTable::getInstance()->getString("NameValue"); +char const* const _PREHASH_PathShearX = LLMessageStringTable::getInstance()->getString("PathShearX"); +char const* const _PREHASH_PathShearY = LLMessageStringTable::getInstance()->getString("PathShearY"); +char const* const _PREHASH_Velocity = LLMessageStringTable::getInstance()->getString("Velocity"); +char const* const _PREHASH_SecPerYear = LLMessageStringTable::getInstance()->getString("SecPerYear"); +char const* const _PREHASH_FirstName = LLMessageStringTable::getInstance()->getString("FirstName"); +char const* const _PREHASH_AttachedSoundGainChange = LLMessageStringTable::getInstance()->getString("AttachedSoundGainChange"); +char const* const _PREHASH_LocationID = LLMessageStringTable::getInstance()->getString("LocationID"); +char const* const _PREHASH_Running = LLMessageStringTable::getInstance()->getString("Running"); +char const* const _PREHASH_AgentThrottle = LLMessageStringTable::getInstance()->getString("AgentThrottle"); +char const* const _PREHASH_NeighborList = LLMessageStringTable::getInstance()->getString("NeighborList"); +char const* const _PREHASH_PathTaperX = LLMessageStringTable::getInstance()->getString("PathTaperX"); +char const* const _PREHASH_PathTaperY = LLMessageStringTable::getInstance()->getString("PathTaperY"); +char const* const _PREHASH_AgentRelated = LLMessageStringTable::getInstance()->getString("AgentRelated"); +char const* const _PREHASH_GranterBlock = LLMessageStringTable::getInstance()->getString("GranterBlock"); +char const* const _PREHASH_UseCachedMuteList = LLMessageStringTable::getInstance()->getString("UseCachedMuteList"); +char const* const _PREHASH_FailStats = LLMessageStringTable::getInstance()->getString("FailStats"); +char const* const _PREHASH_Tempfile = LLMessageStringTable::getInstance()->getString("Tempfile"); +char const* const _PREHASH_BuyerID = LLMessageStringTable::getInstance()->getString("BuyerID"); +char const* const _PREHASH_DirPeopleReply = LLMessageStringTable::getInstance()->getString("DirPeopleReply"); +char const* const _PREHASH_TransferInfo = LLMessageStringTable::getInstance()->getString("TransferInfo"); +char const* const _PREHASH_AvatarPickerRequestBackend = LLMessageStringTable::getInstance()->getString("AvatarPickerRequestBackend"); +char const* const _PREHASH_AvatarPropertiesRequestBackend = LLMessageStringTable::getInstance()->getString("AvatarPropertiesRequestBackend"); +char const* const _PREHASH_UpdateData = LLMessageStringTable::getInstance()->getString("UpdateData"); +char const* const _PREHASH_SimFPS = LLMessageStringTable::getInstance()->getString("SimFPS"); +char const* const _PREHASH_ReporterID = LLMessageStringTable::getInstance()->getString("ReporterID"); +char const* const _PREHASH_ButtonLabel = LLMessageStringTable::getInstance()->getString("ButtonLabel"); +char const* const _PREHASH_GranterID = LLMessageStringTable::getInstance()->getString("GranterID"); +char const* const _PREHASH_WantToText = LLMessageStringTable::getInstance()->getString("WantToText"); +char const* const _PREHASH_ReportType = LLMessageStringTable::getInstance()->getString("ReportType"); +char const* const _PREHASH_SimulatorReady = LLMessageStringTable::getInstance()->getString("SimulatorReady"); +char const* const _PREHASH_DataBlock = LLMessageStringTable::getInstance()->getString("DataBlock"); +char const* const _PREHASH_AnimationSourceList = LLMessageStringTable::getInstance()->getString("AnimationSourceList"); +char const* const _PREHASH_SubscribeLoad = LLMessageStringTable::getInstance()->getString("SubscribeLoad"); +char const* const _PREHASH_UnsubscribeLoad = LLMessageStringTable::getInstance()->getString("UnsubscribeLoad"); +char const* const _PREHASH_Packet = LLMessageStringTable::getInstance()->getString("Packet"); +char const* const _PREHASH_UndoLand = LLMessageStringTable::getInstance()->getString("UndoLand"); +char const* const _PREHASH_SimAccess = LLMessageStringTable::getInstance()->getString("SimAccess"); +char const* const _PREHASH_AbuserID = LLMessageStringTable::getInstance()->getString("AbuserID"); +char const* const _PREHASH_MembershipFee = LLMessageStringTable::getInstance()->getString("MembershipFee"); +char const* const _PREHASH_InviteGroupResponse = LLMessageStringTable::getInstance()->getString("InviteGroupResponse"); +char const* const _PREHASH_CreateInventoryFolder = LLMessageStringTable::getInstance()->getString("CreateInventoryFolder"); +char const* const _PREHASH_UpdateInventoryFolder = LLMessageStringTable::getInstance()->getString("UpdateInventoryFolder"); +char const* const _PREHASH_MoveInventoryFolder = LLMessageStringTable::getInstance()->getString("MoveInventoryFolder"); +char const* const _PREHASH_RemoveInventoryFolder = LLMessageStringTable::getInstance()->getString("RemoveInventoryFolder"); +char const* const _PREHASH_MoneyData = LLMessageStringTable::getInstance()->getString("MoneyData"); +char const* const _PREHASH_ObjectDeselect = LLMessageStringTable::getInstance()->getString("ObjectDeselect"); +char const* const _PREHASH_NewAssetID = LLMessageStringTable::getInstance()->getString("NewAssetID"); +char const* const _PREHASH_ObjectAdd = LLMessageStringTable::getInstance()->getString("ObjectAdd"); +char const* const _PREHASH_SimulatorFeatures = LLMessageStringTable::getInstance()->getString("SimulatorFeatures"); +char const* const _PREHASH_RayEndIsIntersection = LLMessageStringTable::getInstance()->getString("RayEndIsIntersection"); +char const* const _PREHASH_CompleteAuction = LLMessageStringTable::getInstance()->getString("CompleteAuction"); +char const* const _PREHASH_CircuitCode = LLMessageStringTable::getInstance()->getString("CircuitCode"); +char const* const _PREHASH_AgentMovementComplete = LLMessageStringTable::getInstance()->getString("AgentMovementComplete"); +char const* const _PREHASH_ViewerIP = LLMessageStringTable::getInstance()->getString("ViewerIP"); +char const* const _PREHASH_Header = LLMessageStringTable::getInstance()->getString("Header"); +char const* const _PREHASH_GestureFlags = LLMessageStringTable::getInstance()->getString("GestureFlags"); +char const* const _PREHASH_XferID = LLMessageStringTable::getInstance()->getString("XferID"); +char const* const _PREHASH_StatValue = LLMessageStringTable::getInstance()->getString("StatValue"); +char const* const _PREHASH_TaskID = LLMessageStringTable::getInstance()->getString("TaskID"); +char const* const _PREHASH_PickID = LLMessageStringTable::getInstance()->getString("PickID"); +char const* const _PREHASH_RayEnd = LLMessageStringTable::getInstance()->getString("RayEnd"); +char const* const _PREHASH_Throttles = LLMessageStringTable::getInstance()->getString("Throttles"); +char const* const _PREHASH_RebakeAvatarTextures = LLMessageStringTable::getInstance()->getString("RebakeAvatarTextures"); +char const* const _PREHASH_UpAxis = LLMessageStringTable::getInstance()->getString("UpAxis"); +char const* const _PREHASH_AgentTextures = LLMessageStringTable::getInstance()->getString("AgentTextures"); +char const* const _PREHASH_NotecardData = LLMessageStringTable::getInstance()->getString("NotecardData"); +char const* const _PREHASH_Radius = LLMessageStringTable::getInstance()->getString("Radius"); +char const* const _PREHASH_OffCircuit = LLMessageStringTable::getInstance()->getString("OffCircuit"); +char const* const _PREHASH_Access = LLMessageStringTable::getInstance()->getString("Access"); +char const* const _PREHASH_TitleRoleID = LLMessageStringTable::getInstance()->getString("TitleRoleID"); +char const* const _PREHASH_SquareMetersCredit = LLMessageStringTable::getInstance()->getString("SquareMetersCredit"); +char const* const _PREHASH_Filename = LLMessageStringTable::getInstance()->getString("Filename"); +char const* const _PREHASH_ClassifiedInfoRequest = LLMessageStringTable::getInstance()->getString("ClassifiedInfoRequest"); +char const* const _PREHASH_ParcelInfoRequest = LLMessageStringTable::getInstance()->getString("ParcelInfoRequest"); +char const* const _PREHASH_ParcelObjectOwnersRequest = LLMessageStringTable::getInstance()->getString("ParcelObjectOwnersRequest"); +char const* const _PREHASH_TeleportLandmarkRequest = LLMessageStringTable::getInstance()->getString("TeleportLandmarkRequest"); +char const* const _PREHASH_EventInfoRequest = LLMessageStringTable::getInstance()->getString("EventInfoRequest"); +char const* const _PREHASH_MoneyBalanceRequest = LLMessageStringTable::getInstance()->getString("MoneyBalanceRequest"); +char const* const _PREHASH_GroupMembersRequest = LLMessageStringTable::getInstance()->getString("GroupMembersRequest"); +char const* const _PREHASH_GroupRoleMembersRequest = LLMessageStringTable::getInstance()->getString("GroupRoleMembersRequest"); +char const* const _PREHASH_ChatFromSimulator = LLMessageStringTable::getInstance()->getString("ChatFromSimulator"); +char const* const _PREHASH_OldFolderID = LLMessageStringTable::getInstance()->getString("OldFolderID"); +char const* const _PREHASH_UserInfoRequest = LLMessageStringTable::getInstance()->getString("UserInfoRequest"); +char const* const _PREHASH_TextureID = LLMessageStringTable::getInstance()->getString("TextureID"); +char const* const _PREHASH_ProfileURL = LLMessageStringTable::getInstance()->getString("ProfileURL"); +char const* const _PREHASH_Handle = LLMessageStringTable::getInstance()->getString("Handle"); +char const* const _PREHASH_ButtonIndex = LLMessageStringTable::getInstance()->getString("ButtonIndex"); +char const* const _PREHASH_GetScriptRunning = LLMessageStringTable::getInstance()->getString("GetScriptRunning"); +char const* const _PREHASH_SetScriptRunning = LLMessageStringTable::getInstance()->getString("SetScriptRunning"); +char const* const _PREHASH_Health = LLMessageStringTable::getInstance()->getString("Health"); +char const* const _PREHASH_CircuitInfo = LLMessageStringTable::getInstance()->getString("CircuitInfo"); +char const* const _PREHASH_ObjectBuy = LLMessageStringTable::getInstance()->getString("ObjectBuy"); +char const* const _PREHASH_ProfileEnd = LLMessageStringTable::getInstance()->getString("ProfileEnd"); +char const* const _PREHASH_Effect = LLMessageStringTable::getInstance()->getString("Effect"); +char const* const _PREHASH_TestMessage = LLMessageStringTable::getInstance()->getString("TestMessage"); +char const* const _PREHASH_ScriptMailRegistration = LLMessageStringTable::getInstance()->getString("ScriptMailRegistration"); +char const* const _PREHASH_AgentSetAppearance = LLMessageStringTable::getInstance()->getString("AgentSetAppearance"); +char const* const _PREHASH_AvatarAppearance = LLMessageStringTable::getInstance()->getString("AvatarAppearance"); +char const* const _PREHASH_RegionData = LLMessageStringTable::getInstance()->getString("RegionData"); +char const* const _PREHASH_RequestingRegionData = LLMessageStringTable::getInstance()->getString("RequestingRegionData"); +char const* const _PREHASH_LandingRegionData = LLMessageStringTable::getInstance()->getString("LandingRegionData"); +char const* const _PREHASH_SitTransform = LLMessageStringTable::getInstance()->getString("SitTransform"); +char const* const _PREHASH_TerrainBase0 = LLMessageStringTable::getInstance()->getString("TerrainBase0"); +char const* const _PREHASH_SkillsMask = LLMessageStringTable::getInstance()->getString("SkillsMask"); +char const* const _PREHASH_AtAxis = LLMessageStringTable::getInstance()->getString("AtAxis"); +char const* const _PREHASH_TerrainBase1 = LLMessageStringTable::getInstance()->getString("TerrainBase1"); +char const* const _PREHASH_Reason = LLMessageStringTable::getInstance()->getString("Reason"); +char const* const _PREHASH_TerrainBase2 = LLMessageStringTable::getInstance()->getString("TerrainBase2"); +char const* const _PREHASH_TerrainBase3 = LLMessageStringTable::getInstance()->getString("TerrainBase3"); +char const* const _PREHASH_Params = LLMessageStringTable::getInstance()->getString("Params"); +char const* const _PREHASH_PingID = LLMessageStringTable::getInstance()->getString("PingID"); +char const* const _PREHASH_Change = LLMessageStringTable::getInstance()->getString("Change"); +char const* const _PREHASH_Height = LLMessageStringTable::getInstance()->getString("Height"); +char const* const _PREHASH_Region = LLMessageStringTable::getInstance()->getString("Region"); +char const* const _PREHASH_TelehubInfo = LLMessageStringTable::getInstance()->getString("TelehubInfo"); +char const* const _PREHASH_StateSave = LLMessageStringTable::getInstance()->getString("StateSave"); +char const* const _PREHASH_RoleData = LLMessageStringTable::getInstance()->getString("RoleData"); +char const* const _PREHASH_AgentAnimation = LLMessageStringTable::getInstance()->getString("AgentAnimation"); +char const* const _PREHASH_AvatarAnimation = LLMessageStringTable::getInstance()->getString("AvatarAnimation"); +char const* const _PREHASH_LogDwellTime = LLMessageStringTable::getInstance()->getString("LogDwellTime"); +char const* const _PREHASH_ParcelGodMarkAsContent = LLMessageStringTable::getInstance()->getString("ParcelGodMarkAsContent"); +char const* const _PREHASH_UsePhysics = LLMessageStringTable::getInstance()->getString("UsePhysics"); +char const* const _PREHASH_RegionDenyTransacted = LLMessageStringTable::getInstance()->getString("RegionDenyTransacted"); +char const* const _PREHASH_JointType = LLMessageStringTable::getInstance()->getString("JointType"); +char const* const _PREHASH_ObjectTaxEstimate = LLMessageStringTable::getInstance()->getString("ObjectTaxEstimate"); +char const* const _PREHASH_LightTaxEstimate = LLMessageStringTable::getInstance()->getString("LightTaxEstimate"); +char const* const _PREHASH_LandTaxEstimate = LLMessageStringTable::getInstance()->getString("LandTaxEstimate"); +char const* const _PREHASH_TeleportLandingStatusChanged = LLMessageStringTable::getInstance()->getString("TeleportLandingStatusChanged"); +char const* const _PREHASH_GroupTaxEstimate = LLMessageStringTable::getInstance()->getString("GroupTaxEstimate"); +char const* const _PREHASH_AvgViewerFPS = LLMessageStringTable::getInstance()->getString("AvgViewerFPS"); +char const* const _PREHASH_Buttons = LLMessageStringTable::getInstance()->getString("Buttons"); +char const* const _PREHASH_Sender = LLMessageStringTable::getInstance()->getString("Sender"); +char const* const _PREHASH_Dialog = LLMessageStringTable::getInstance()->getString("Dialog"); +char const* const _PREHASH_TargetData = LLMessageStringTable::getInstance()->getString("TargetData"); +char const* const _PREHASH_DestID = LLMessageStringTable::getInstance()->getString("DestID"); +char const* const _PREHASH_PricePublicObjectDelete = LLMessageStringTable::getInstance()->getString("PricePublicObjectDelete"); +char const* const _PREHASH_ObjectDelete = LLMessageStringTable::getInstance()->getString("ObjectDelete"); +char const* const _PREHASH_Delete = LLMessageStringTable::getInstance()->getString("Delete"); +char const* const _PREHASH_EventGodDelete = LLMessageStringTable::getInstance()->getString("EventGodDelete"); +char const* const _PREHASH_LastTaxDate = LLMessageStringTable::getInstance()->getString("LastTaxDate"); +char const* const _PREHASH_MapImageID = LLMessageStringTable::getInstance()->getString("MapImageID"); +char const* const _PREHASH_EndDateTime = LLMessageStringTable::getInstance()->getString("EndDateTime"); +char const* const _PREHASH_TerrainDetail0 = LLMessageStringTable::getInstance()->getString("TerrainDetail0"); +char const* const _PREHASH_TerrainDetail1 = LLMessageStringTable::getInstance()->getString("TerrainDetail1"); +char const* const _PREHASH_TerrainDetail2 = LLMessageStringTable::getInstance()->getString("TerrainDetail2"); +char const* const _PREHASH_TerrainDetail3 = LLMessageStringTable::getInstance()->getString("TerrainDetail3"); +char const* const _PREHASH_Offset = LLMessageStringTable::getInstance()->getString("Offset"); +char const* const _PREHASH_ObjectDelink = LLMessageStringTable::getInstance()->getString("ObjectDelink"); +char const* const _PREHASH_TargetObject = LLMessageStringTable::getInstance()->getString("TargetObject"); +char const* const _PREHASH_IsEstateManager = LLMessageStringTable::getInstance()->getString("IsEstateManager"); +char const* const _PREHASH_CancelAuction = LLMessageStringTable::getInstance()->getString("CancelAuction"); +char const* const _PREHASH_ObjectDetach = LLMessageStringTable::getInstance()->getString("ObjectDetach"); +char const* const _PREHASH_Compressed = LLMessageStringTable::getInstance()->getString("Compressed"); +char const* const _PREHASH_PathBegin = LLMessageStringTable::getInstance()->getString("PathBegin"); +char const* const _PREHASH_BypassRaycast = LLMessageStringTable::getInstance()->getString("BypassRaycast"); +char const* const _PREHASH_WinnerID = LLMessageStringTable::getInstance()->getString("WinnerID"); +char const* const _PREHASH_ChannelType = LLMessageStringTable::getInstance()->getString("ChannelType"); +char const* const _PREHASH_NonExemptMembers = LLMessageStringTable::getInstance()->getString("NonExemptMembers"); +char const* const _PREHASH_Agents = LLMessageStringTable::getInstance()->getString("Agents"); +char const* const _PREHASH_MemberData = LLMessageStringTable::getInstance()->getString("MemberData"); +char const* const _PREHASH_ToGroupID = LLMessageStringTable::getInstance()->getString("ToGroupID"); +char const* const _PREHASH_ImageNotInDatabase = LLMessageStringTable::getInstance()->getString("ImageNotInDatabase"); +char const* const _PREHASH_StartDate = LLMessageStringTable::getInstance()->getString("StartDate"); +char const* const _PREHASH_AnimID = LLMessageStringTable::getInstance()->getString("AnimID"); +char const* const _PREHASH_Serial = LLMessageStringTable::getInstance()->getString("Serial"); +char const* const _PREHASH_AbuseRegionName = LLMessageStringTable::getInstance()->getString("AbuseRegionName"); +char const* const _PREHASH_ModifyLand = LLMessageStringTable::getInstance()->getString("ModifyLand"); +char const* const _PREHASH_Digest = LLMessageStringTable::getInstance()->getString("Digest"); +char const* const _PREHASH_Victim = LLMessageStringTable::getInstance()->getString("Victim"); +char const* const _PREHASH_Script = LLMessageStringTable::getInstance()->getString("Script"); +char const* const _PREHASH_PickInfoReply = LLMessageStringTable::getInstance()->getString("PickInfoReply"); +char const* const _PREHASH_MoneyBalanceReply = LLMessageStringTable::getInstance()->getString("MoneyBalanceReply"); +char const* const _PREHASH_RoutedMoneyBalanceReply = LLMessageStringTable::getInstance()->getString("RoutedMoneyBalanceReply"); +char const* const _PREHASH_RoleID = LLMessageStringTable::getInstance()->getString("RoleID"); +char const* const _PREHASH_RegionInfo = LLMessageStringTable::getInstance()->getString("RegionInfo"); +char const* const _PREHASH_GodUpdateRegionInfo = LLMessageStringTable::getInstance()->getString("GodUpdateRegionInfo"); +char const* const _PREHASH_StartAnim = LLMessageStringTable::getInstance()->getString("StartAnim"); +char const* const _PREHASH_Action = LLMessageStringTable::getInstance()->getString("Action"); +char const* const _PREHASH_Location = LLMessageStringTable::getInstance()->getString("Location"); +char const* const _PREHASH_Rights = LLMessageStringTable::getInstance()->getString("Rights"); +char const* const _PREHASH_SearchDir = LLMessageStringTable::getInstance()->getString("SearchDir"); +char const* const _PREHASH_TransferRequest = LLMessageStringTable::getInstance()->getString("TransferRequest"); +char const* const _PREHASH_ScriptSensorRequest = LLMessageStringTable::getInstance()->getString("ScriptSensorRequest"); +char const* const _PREHASH_MoneyTransferRequest = LLMessageStringTable::getInstance()->getString("MoneyTransferRequest"); +char const* const _PREHASH_EjectGroupMemberRequest = LLMessageStringTable::getInstance()->getString("EjectGroupMemberRequest"); +char const* const _PREHASH_SkillsText = LLMessageStringTable::getInstance()->getString("SkillsText"); +char const* const _PREHASH_Resent = LLMessageStringTable::getInstance()->getString("Resent"); +char const* const _PREHASH_Center = LLMessageStringTable::getInstance()->getString("Center"); +char const* const _PREHASH_SharedData = LLMessageStringTable::getInstance()->getString("SharedData"); +char const* const _PREHASH_PSBlock = LLMessageStringTable::getInstance()->getString("PSBlock"); +char const* const _PREHASH_UUIDNameBlock = LLMessageStringTable::getInstance()->getString("UUIDNameBlock"); +char const* const _PREHASH_GroupTitleUpdate = LLMessageStringTable::getInstance()->getString("GroupTitleUpdate"); +char const* const _PREHASH_Method = LLMessageStringTable::getInstance()->getString("Method"); +char const* const _PREHASH_TouchName = LLMessageStringTable::getInstance()->getString("TouchName"); +char const* const _PREHASH_UpdateType = LLMessageStringTable::getInstance()->getString("UpdateType"); +char const* const _PREHASH_KickedFromEstateID = LLMessageStringTable::getInstance()->getString("KickedFromEstateID"); +char const* const _PREHASH_CandidateID = LLMessageStringTable::getInstance()->getString("CandidateID"); +char const* const _PREHASH_ParamData = LLMessageStringTable::getInstance()->getString("ParamData"); +char const* const _PREHASH_GodlikeMessage = LLMessageStringTable::getInstance()->getString("GodlikeMessage"); +char const* const _PREHASH_SystemMessage = LLMessageStringTable::getInstance()->getString("SystemMessage"); +char const* const _PREHASH_BodyRotation = LLMessageStringTable::getInstance()->getString("BodyRotation"); +char const* const _PREHASH_SearchRegions = LLMessageStringTable::getInstance()->getString("SearchRegions"); +char const* const _PREHASH_AnimationData = LLMessageStringTable::getInstance()->getString("AnimationData"); +char const* const _PREHASH_StatID = LLMessageStringTable::getInstance()->getString("StatID"); +char const* const _PREHASH_ItemID = LLMessageStringTable::getInstance()->getString("ItemID"); +char const* const _PREHASH_ScriptDialogReply = LLMessageStringTable::getInstance()->getString("ScriptDialogReply"); +char const* const _PREHASH_RegionIDAndHandleReply = LLMessageStringTable::getInstance()->getString("RegionIDAndHandleReply"); +char const* const _PREHASH_CameraAtOffset = LLMessageStringTable::getInstance()->getString("CameraAtOffset"); +char const* const _PREHASH_VoteID = LLMessageStringTable::getInstance()->getString("VoteID"); +char const* const _PREHASH_ParcelGodForceOwner = LLMessageStringTable::getInstance()->getString("ParcelGodForceOwner"); +char const* const _PREHASH_Filter = LLMessageStringTable::getInstance()->getString("Filter"); +char const* const _PREHASH_InviteData = LLMessageStringTable::getInstance()->getString("InviteData"); +char const* const _PREHASH_PCode = LLMessageStringTable::getInstance()->getString("PCode"); +char const* const _PREHASH_SearchPos = LLMessageStringTable::getInstance()->getString("SearchPos"); +char const* const _PREHASH_PreyID = LLMessageStringTable::getInstance()->getString("PreyID"); +char const* const _PREHASH_TerrainLowerLimit = LLMessageStringTable::getInstance()->getString("TerrainLowerLimit"); +char const* const _PREHASH_EventFlags = LLMessageStringTable::getInstance()->getString("EventFlags"); +char const* const _PREHASH_TallyVotes = LLMessageStringTable::getInstance()->getString("TallyVotes"); +char const* const _PREHASH_Result = LLMessageStringTable::getInstance()->getString("Result"); +char const* const _PREHASH_LookAt = LLMessageStringTable::getInstance()->getString("LookAt"); +char const* const _PREHASH_SearchOrder = LLMessageStringTable::getInstance()->getString("SearchOrder"); +char const* const _PREHASH_PayButton = LLMessageStringTable::getInstance()->getString("PayButton"); +char const* const _PREHASH_SelfCount = LLMessageStringTable::getInstance()->getString("SelfCount"); +char const* const _PREHASH_PacketCount = LLMessageStringTable::getInstance()->getString("PacketCount"); +char const* const _PREHASH_ParcelBuyPass = LLMessageStringTable::getInstance()->getString("ParcelBuyPass"); +char const* const _PREHASH_OldItemID = LLMessageStringTable::getInstance()->getString("OldItemID"); +char const* const _PREHASH_RegionPort = LLMessageStringTable::getInstance()->getString("RegionPort"); +char const* const _PREHASH_PriceEnergyUnit = LLMessageStringTable::getInstance()->getString("PriceEnergyUnit"); +char const* const _PREHASH_Bitmap = LLMessageStringTable::getInstance()->getString("Bitmap"); +char const* const _PREHASH_CacheMissType = LLMessageStringTable::getInstance()->getString("CacheMissType"); +char const* const _PREHASH_VFileID = LLMessageStringTable::getInstance()->getString("VFileID"); +char const* const _PREHASH_GroupInsigniaID = LLMessageStringTable::getInstance()->getString("GroupInsigniaID"); +char const* const _PREHASH_Online = LLMessageStringTable::getInstance()->getString("Online"); +char const* const _PREHASH_KickFlags = LLMessageStringTable::getInstance()->getString("KickFlags"); +char const* const _PREHASH_CovenantID = LLMessageStringTable::getInstance()->getString("CovenantID"); +char const* const _PREHASH_SysCPU = LLMessageStringTable::getInstance()->getString("SysCPU"); +char const* const _PREHASH_EMail = LLMessageStringTable::getInstance()->getString("EMail"); +char const* const _PREHASH_AggregatePermTextures = LLMessageStringTable::getInstance()->getString("AggregatePermTextures"); +char const* const _PREHASH_ChatChannel = LLMessageStringTable::getInstance()->getString("ChatChannel"); +char const* const _PREHASH_ReturnID = LLMessageStringTable::getInstance()->getString("ReturnID"); +char const* const _PREHASH_ObjectAttach = LLMessageStringTable::getInstance()->getString("ObjectAttach"); +char const* const _PREHASH_TargetPort = LLMessageStringTable::getInstance()->getString("TargetPort"); +char const* const _PREHASH_ObjectSpinStop = LLMessageStringTable::getInstance()->getString("ObjectSpinStop"); +char const* const _PREHASH_FullID = LLMessageStringTable::getInstance()->getString("FullID"); +char const* const _PREHASH_ActivateGroup = LLMessageStringTable::getInstance()->getString("ActivateGroup"); +char const* const _PREHASH_SysGPU = LLMessageStringTable::getInstance()->getString("SysGPU"); +char const* const _PREHASH_AvatarInterestsReply = LLMessageStringTable::getInstance()->getString("AvatarInterestsReply"); +char const* const _PREHASH_StartLure = LLMessageStringTable::getInstance()->getString("StartLure"); +char const* const _PREHASH_SysRAM = LLMessageStringTable::getInstance()->getString("SysRAM"); +char const* const _PREHASH_ObjectPosition = LLMessageStringTable::getInstance()->getString("ObjectPosition"); +char const* const _PREHASH_SitPosition = LLMessageStringTable::getInstance()->getString("SitPosition"); +char const* const _PREHASH_StartTime = LLMessageStringTable::getInstance()->getString("StartTime"); +char const* const _PREHASH_BornOn = LLMessageStringTable::getInstance()->getString("BornOn"); +char const* const _PREHASH_CameraCollidePlane = LLMessageStringTable::getInstance()->getString("CameraCollidePlane"); +char const* const _PREHASH_EconomyDataRequest = LLMessageStringTable::getInstance()->getString("EconomyDataRequest"); +char const* const _PREHASH_TeleportLureRequest = LLMessageStringTable::getInstance()->getString("TeleportLureRequest"); +char const* const _PREHASH_FolderID = LLMessageStringTable::getInstance()->getString("FolderID"); +char const* const _PREHASH_RegionHandleRequest = LLMessageStringTable::getInstance()->getString("RegionHandleRequest"); +char const* const _PREHASH_ScriptDataRequest = LLMessageStringTable::getInstance()->getString("ScriptDataRequest"); +char const* const _PREHASH_GroupRoleDataRequest = LLMessageStringTable::getInstance()->getString("GroupRoleDataRequest"); +char const* const _PREHASH_GroupTitlesRequest = LLMessageStringTable::getInstance()->getString("GroupTitlesRequest"); +char const* const _PREHASH_AgentWearablesRequest = LLMessageStringTable::getInstance()->getString("AgentWearablesRequest"); +char const* const _PREHASH_MapBlockRequest = LLMessageStringTable::getInstance()->getString("MapBlockRequest"); +char const* const _PREHASH_LureID = LLMessageStringTable::getInstance()->getString("LureID"); +char const* const _PREHASH_CopyCenters = LLMessageStringTable::getInstance()->getString("CopyCenters"); +char const* const _PREHASH_ParamList = LLMessageStringTable::getInstance()->getString("ParamList"); +char const* const _PREHASH_InventorySerial = LLMessageStringTable::getInstance()->getString("InventorySerial"); +char const* const _PREHASH_EdgeDataPacket = LLMessageStringTable::getInstance()->getString("EdgeDataPacket"); +char const* const _PREHASH_AvatarPickerReply = LLMessageStringTable::getInstance()->getString("AvatarPickerReply"); +char const* const _PREHASH_ParcelDwellReply = LLMessageStringTable::getInstance()->getString("ParcelDwellReply"); +char const* const _PREHASH_IsForSale = LLMessageStringTable::getInstance()->getString("IsForSale"); +char const* const _PREHASH_MuteID = LLMessageStringTable::getInstance()->getString("MuteID"); +char const* const _PREHASH_MeanCollisionAlert = LLMessageStringTable::getInstance()->getString("MeanCollisionAlert"); +char const* const _PREHASH_CanAcceptTasks = LLMessageStringTable::getInstance()->getString("CanAcceptTasks"); +char const* const _PREHASH_ItemData = LLMessageStringTable::getInstance()->getString("ItemData"); +char const* const _PREHASH_AnimationList = LLMessageStringTable::getInstance()->getString("AnimationList"); +char const* const _PREHASH_Reputation = LLMessageStringTable::getInstance()->getString("Reputation"); +char const* const _PREHASH_IntValue = LLMessageStringTable::getInstance()->getString("IntValue"); +char const* const _PREHASH_TargetType = LLMessageStringTable::getInstance()->getString("TargetType"); +char const* const _PREHASH_Amount = LLMessageStringTable::getInstance()->getString("Amount"); +char const* const _PREHASH_HasAttachment = LLMessageStringTable::getInstance()->getString("HasAttachment"); +char const* const _PREHASH_UpdateAttachment = LLMessageStringTable::getInstance()->getString("UpdateAttachment"); +char const* const _PREHASH_RemoveAttachment = LLMessageStringTable::getInstance()->getString("RemoveAttachment"); +char const* const _PREHASH_HeightWidthBlock = LLMessageStringTable::getInstance()->getString("HeightWidthBlock"); +char const* const _PREHASH_RequestObjectPropertiesFamily = LLMessageStringTable::getInstance()->getString("RequestObjectPropertiesFamily"); +char const* const _PREHASH_ObjectPropertiesFamily = LLMessageStringTable::getInstance()->getString("ObjectPropertiesFamily"); +char const* const _PREHASH_UserData = LLMessageStringTable::getInstance()->getString("UserData"); +char const* const _PREHASH_IsReadable = LLMessageStringTable::getInstance()->getString("IsReadable"); +char const* const _PREHASH_PathCurve = LLMessageStringTable::getInstance()->getString("PathCurve"); +char const* const _PREHASH_Status = LLMessageStringTable::getInstance()->getString("Status"); +char const* const _PREHASH_FromGroup = LLMessageStringTable::getInstance()->getString("FromGroup"); +char const* const _PREHASH_AlreadyVoted = LLMessageStringTable::getInstance()->getString("AlreadyVoted"); +char const* const _PREHASH_PlacesReply = LLMessageStringTable::getInstance()->getString("PlacesReply"); +char const* const _PREHASH_DirPlacesReply = LLMessageStringTable::getInstance()->getString("DirPlacesReply"); +char const* const _PREHASH_ParcelBuy = LLMessageStringTable::getInstance()->getString("ParcelBuy"); +char const* const _PREHASH_DirFindQueryBackend = LLMessageStringTable::getInstance()->getString("DirFindQueryBackend"); +char const* const _PREHASH_DirPlacesQueryBackend = LLMessageStringTable::getInstance()->getString("DirPlacesQueryBackend"); +char const* const _PREHASH_DirClassifiedQueryBackend = LLMessageStringTable::getInstance()->getString("DirClassifiedQueryBackend"); +char const* const _PREHASH_DirLandQueryBackend = LLMessageStringTable::getInstance()->getString("DirLandQueryBackend"); +char const* const _PREHASH_DirPopularQueryBackend = LLMessageStringTable::getInstance()->getString("DirPopularQueryBackend"); +char const* const _PREHASH_HistoryData = LLMessageStringTable::getInstance()->getString("HistoryData"); +char const* const _PREHASH_SnapshotID = LLMessageStringTable::getInstance()->getString("SnapshotID"); +char const* const _PREHASH_Aspect = LLMessageStringTable::getInstance()->getString("Aspect"); +char const* const _PREHASH_ParamSize = LLMessageStringTable::getInstance()->getString("ParamSize"); +char const* const _PREHASH_VoteCast = LLMessageStringTable::getInstance()->getString("VoteCast"); +char const* const _PREHASH_CastsShadows = LLMessageStringTable::getInstance()->getString("CastsShadows"); +char const* const _PREHASH_EveryoneMask = LLMessageStringTable::getInstance()->getString("EveryoneMask"); +char const* const _PREHASH_ObjectSpinUpdate = LLMessageStringTable::getInstance()->getString("ObjectSpinUpdate"); +char const* const _PREHASH_MaturePublish = LLMessageStringTable::getInstance()->getString("MaturePublish"); +char const* const _PREHASH_UseExistingAsset = LLMessageStringTable::getInstance()->getString("UseExistingAsset"); +char const* const _PREHASH_Powers = LLMessageStringTable::getInstance()->getString("Powers"); +char const* const _PREHASH_ParcelLocalID = LLMessageStringTable::getInstance()->getString("ParcelLocalID"); +char const* const _PREHASH_TeleportCancel = LLMessageStringTable::getInstance()->getString("TeleportCancel"); +char const* const _PREHASH_UnixTime = LLMessageStringTable::getInstance()->getString("UnixTime"); +char const* const _PREHASH_QueryFlags = LLMessageStringTable::getInstance()->getString("QueryFlags"); +char const* const _PREHASH_AlwaysRun = LLMessageStringTable::getInstance()->getString("AlwaysRun"); +char const* const _PREHASH_Bottom = LLMessageStringTable::getInstance()->getString("Bottom"); +char const* const _PREHASH_ButtonData = LLMessageStringTable::getInstance()->getString("ButtonData"); +char const* const _PREHASH_SoundData = LLMessageStringTable::getInstance()->getString("SoundData"); +char const* const _PREHASH_ViewerStats = LLMessageStringTable::getInstance()->getString("ViewerStats"); +char const* const _PREHASH_RegionHandshake = LLMessageStringTable::getInstance()->getString("RegionHandshake"); +char const* const _PREHASH_ObjectDescription = LLMessageStringTable::getInstance()->getString("ObjectDescription"); +char const* const _PREHASH_Description = LLMessageStringTable::getInstance()->getString("Description"); +char const* const _PREHASH_ParamType = LLMessageStringTable::getInstance()->getString("ParamType"); +char const* const _PREHASH_UUIDNameReply = LLMessageStringTable::getInstance()->getString("UUIDNameReply"); +char const* const _PREHASH_UUIDGroupNameReply = LLMessageStringTable::getInstance()->getString("UUIDGroupNameReply"); +char const* const _PREHASH_SaveAssetIntoInventory = LLMessageStringTable::getInstance()->getString("SaveAssetIntoInventory"); +char const* const _PREHASH_UserInfo = LLMessageStringTable::getInstance()->getString("UserInfo"); +char const* const _PREHASH_AnimSequenceID = LLMessageStringTable::getInstance()->getString("AnimSequenceID"); +char const* const _PREHASH_NVPairs = LLMessageStringTable::getInstance()->getString("NVPairs"); +char const* const _PREHASH_GroupNoticesListRequest = LLMessageStringTable::getInstance()->getString("GroupNoticesListRequest"); +char const* const _PREHASH_ParcelAccessListRequest = LLMessageStringTable::getInstance()->getString("ParcelAccessListRequest"); +char const* const _PREHASH_MuteListRequest = LLMessageStringTable::getInstance()->getString("MuteListRequest"); +char const* const _PREHASH_RpcChannelRequest = LLMessageStringTable::getInstance()->getString("RpcChannelRequest"); +char const* const _PREHASH_LandStatRequest = LLMessageStringTable::getInstance()->getString("LandStatRequest"); +char const* const _PREHASH_PlacesQuery = LLMessageStringTable::getInstance()->getString("PlacesQuery"); +char const* const _PREHASH_DirPlacesQuery = LLMessageStringTable::getInstance()->getString("DirPlacesQuery"); +char const* const _PREHASH_SortOrder = LLMessageStringTable::getInstance()->getString("SortOrder"); +char const* const _PREHASH_Hunter = LLMessageStringTable::getInstance()->getString("Hunter"); +char const* const _PREHASH_SunAngVelocity = LLMessageStringTable::getInstance()->getString("SunAngVelocity"); +char const* const _PREHASH_BinaryBucket = LLMessageStringTable::getInstance()->getString("BinaryBucket"); +char const* const _PREHASH_ImagePacket = LLMessageStringTable::getInstance()->getString("ImagePacket"); +char const* const _PREHASH_StartGroupProposal = LLMessageStringTable::getInstance()->getString("StartGroupProposal"); +char const* const _PREHASH_EnergyLevel = LLMessageStringTable::getInstance()->getString("EnergyLevel"); +char const* const _PREHASH_PriceForListing = LLMessageStringTable::getInstance()->getString("PriceForListing"); +char const* const _PREHASH_Scale = LLMessageStringTable::getInstance()->getString("Scale"); +char const* const _PREHASH_EstateCovenantReply = LLMessageStringTable::getInstance()->getString("EstateCovenantReply"); +char const* const _PREHASH_ParentEstateID = LLMessageStringTable::getInstance()->getString("ParentEstateID"); +char const* const _PREHASH_Extra2 = LLMessageStringTable::getInstance()->getString("Extra2"); +char const* const _PREHASH_Throttle = LLMessageStringTable::getInstance()->getString("Throttle"); +char const* const _PREHASH_SimIP = LLMessageStringTable::getInstance()->getString("SimIP"); +char const* const _PREHASH_GodID = LLMessageStringTable::getInstance()->getString("GodID"); +char const* const _PREHASH_TeleportMinPrice = LLMessageStringTable::getInstance()->getString("TeleportMinPrice"); +char const* const _PREHASH_VoteItem = LLMessageStringTable::getInstance()->getString("VoteItem"); +char const* const _PREHASH_ObjectRotation = LLMessageStringTable::getInstance()->getString("ObjectRotation"); +char const* const _PREHASH_SitRotation = LLMessageStringTable::getInstance()->getString("SitRotation"); +char const* const _PREHASH_SnapSelection = LLMessageStringTable::getInstance()->getString("SnapSelection"); +char const* const _PREHASH_SoundTrigger = LLMessageStringTable::getInstance()->getString("SoundTrigger"); +char const* const _PREHASH_TerrainRaiseLimit = LLMessageStringTable::getInstance()->getString("TerrainRaiseLimit"); +char const* const _PREHASH_Quorum = LLMessageStringTable::getInstance()->getString("Quorum"); +char const* const _PREHASH_AgentBlock = LLMessageStringTable::getInstance()->getString("AgentBlock"); +char const* const _PREHASH_CommandBlock = LLMessageStringTable::getInstance()->getString("CommandBlock"); +char const* const _PREHASH_PricePublicObjectDecay = LLMessageStringTable::getInstance()->getString("PricePublicObjectDecay"); +char const* const _PREHASH_SpawnPointPos = LLMessageStringTable::getInstance()->getString("SpawnPointPos"); +char const* const _PREHASH_VolumeDetail = LLMessageStringTable::getInstance()->getString("VolumeDetail"); +char const* const _PREHASH_FromAgentName = LLMessageStringTable::getInstance()->getString("FromAgentName"); +char const* const _PREHASH_Range = LLMessageStringTable::getInstance()->getString("Range"); +char const* const _PREHASH_DirectoryVisibility = LLMessageStringTable::getInstance()->getString("DirectoryVisibility"); +char const* const _PREHASH_PublicIP = LLMessageStringTable::getInstance()->getString("PublicIP"); +char const* const _PREHASH_TeleportFailed = LLMessageStringTable::getInstance()->getString("TeleportFailed"); +char const* const _PREHASH_PreloadSound = LLMessageStringTable::getInstance()->getString("PreloadSound"); +char const* const _PREHASH_ScreenshotID = LLMessageStringTable::getInstance()->getString("ScreenshotID"); +char const* const _PREHASH_CovenantTimestamp = LLMessageStringTable::getInstance()->getString("CovenantTimestamp"); +char const* const _PREHASH_OldestUnacked = LLMessageStringTable::getInstance()->getString("OldestUnacked"); +char const* const _PREHASH_SimulatorIP = LLMessageStringTable::getInstance()->getString("SimulatorIP"); +char const* const _PREHASH_Value = LLMessageStringTable::getInstance()->getString("Value"); +char const* const _PREHASH_JointAxisOrAnchor = LLMessageStringTable::getInstance()->getString("JointAxisOrAnchor"); +char const* const _PREHASH_Test0 = LLMessageStringTable::getInstance()->getString("Test0"); +char const* const _PREHASH_Test1 = LLMessageStringTable::getInstance()->getString("Test1"); +char const* const _PREHASH_Test2 = LLMessageStringTable::getInstance()->getString("Test2"); +char const* const _PREHASH_SunPhase = LLMessageStringTable::getInstance()->getString("SunPhase"); +char const* const _PREHASH_ParcelDivide = LLMessageStringTable::getInstance()->getString("ParcelDivide"); +char const* const _PREHASH_PriceObjectClaim = LLMessageStringTable::getInstance()->getString("PriceObjectClaim"); +char const* const _PREHASH_Field = LLMessageStringTable::getInstance()->getString("Field"); +char const* const _PREHASH_Ratio = LLMessageStringTable::getInstance()->getString("Ratio"); +char const* const _PREHASH_JoinGroupReply = LLMessageStringTable::getInstance()->getString("JoinGroupReply"); +char const* const _PREHASH_LiveHelpGroupReply = LLMessageStringTable::getInstance()->getString("LiveHelpGroupReply"); +char const* const _PREHASH_Score = LLMessageStringTable::getInstance()->getString("Score"); +char const* const _PREHASH_Image = LLMessageStringTable::getInstance()->getString("Image"); +char const* const _PREHASH_ObjectClickAction = LLMessageStringTable::getInstance()->getString("ObjectClickAction"); +char const* const _PREHASH_Parameter = LLMessageStringTable::getInstance()->getString("Parameter"); +char const* const _PREHASH_Flags = LLMessageStringTable::getInstance()->getString("Flags"); +char const* const _PREHASH_Plane = LLMessageStringTable::getInstance()->getString("Plane"); +char const* const _PREHASH_Width = LLMessageStringTable::getInstance()->getString("Width"); +char const* const _PREHASH_Right = LLMessageStringTable::getInstance()->getString("Right"); +char const* const _PREHASH_DirFindQuery = LLMessageStringTable::getInstance()->getString("DirFindQuery"); +char const* const _PREHASH_Textures = LLMessageStringTable::getInstance()->getString("Textures"); +char const* const _PREHASH_EventData = LLMessageStringTable::getInstance()->getString("EventData"); +char const* const _PREHASH_Final = LLMessageStringTable::getInstance()->getString("Final"); +char const* const _PREHASH_System = LLMessageStringTable::getInstance()->getString("System"); +char const* const _PREHASH_TelehubPos = LLMessageStringTable::getInstance()->getString("TelehubPos"); +char const* const _PREHASH_ReportAutosaveCrash = LLMessageStringTable::getInstance()->getString("ReportAutosaveCrash"); +char const* const _PREHASH_CreateTrustedCircuit = LLMessageStringTable::getInstance()->getString("CreateTrustedCircuit"); +char const* const _PREHASH_DenyTrustedCircuit = LLMessageStringTable::getInstance()->getString("DenyTrustedCircuit"); +char const* const _PREHASH_RequestTrustedCircuit = LLMessageStringTable::getInstance()->getString("RequestTrustedCircuit"); +char const* const _PREHASH_Codec = LLMessageStringTable::getInstance()->getString("Codec"); +char const* const _PREHASH_Modal = LLMessageStringTable::getInstance()->getString("Modal"); +char const* const _PREHASH_ChildAgentUnknown = LLMessageStringTable::getInstance()->getString("ChildAgentUnknown"); +char const* const _PREHASH_LandingType = LLMessageStringTable::getInstance()->getString("LandingType"); +char const* const _PREHASH_ScriptRunningReply = LLMessageStringTable::getInstance()->getString("ScriptRunningReply"); +char const* const _PREHASH_Reply = LLMessageStringTable::getInstance()->getString("Reply"); +char const* const _PREHASH_GroupAccountDetailsReply = LLMessageStringTable::getInstance()->getString("GroupAccountDetailsReply"); +char const* const _PREHASH_TelehubRot = LLMessageStringTable::getInstance()->getString("TelehubRot"); +char const* const _PREHASH_AcceptFriendship = LLMessageStringTable::getInstance()->getString("AcceptFriendship"); +char const* const _PREHASH_ItemType = LLMessageStringTable::getInstance()->getString("ItemType"); +char const* const _PREHASH_DwellInfo = LLMessageStringTable::getInstance()->getString("DwellInfo"); +char const* const _PREHASH_AgentResume = LLMessageStringTable::getInstance()->getString("AgentResume"); +char const* const _PREHASH_MailFilter = LLMessageStringTable::getInstance()->getString("MailFilter"); +char const* const _PREHASH_Disconnect = LLMessageStringTable::getInstance()->getString("Disconnect"); +char const* const _PREHASH_SimPosition = LLMessageStringTable::getInstance()->getString("SimPosition"); +char const* const _PREHASH_SimWideTotalPrims = LLMessageStringTable::getInstance()->getString("SimWideTotalPrims"); +char const* const _PREHASH_Index = LLMessageStringTable::getInstance()->getString("Index"); +char const* const _PREHASH_SimFilename = LLMessageStringTable::getInstance()->getString("SimFilename"); +char const* const _PREHASH_LastOwnerID = LLMessageStringTable::getInstance()->getString("LastOwnerID"); +char const* const _PREHASH_GroupNoticeRequest = LLMessageStringTable::getInstance()->getString("GroupNoticeRequest"); +char const* const _PREHASH_EmailMessageRequest = LLMessageStringTable::getInstance()->getString("EmailMessageRequest"); +char const* const _PREHASH_MapItemRequest = LLMessageStringTable::getInstance()->getString("MapItemRequest"); +char const* const _PREHASH_AgentCount = LLMessageStringTable::getInstance()->getString("AgentCount"); +char const* const _PREHASH_MessageBlock = LLMessageStringTable::getInstance()->getString("MessageBlock"); +char const* const _PREHASH_FuseBlock = LLMessageStringTable::getInstance()->getString("FuseBlock"); +char const* const _PREHASH_AgentGroupData = LLMessageStringTable::getInstance()->getString("AgentGroupData"); +char const* const _PREHASH_ClassifiedInfoUpdate = LLMessageStringTable::getInstance()->getString("ClassifiedInfoUpdate"); +char const* const _PREHASH_RegionPos = LLMessageStringTable::getInstance()->getString("RegionPos"); +char const* const _PREHASH_ParcelMediaUpdate = LLMessageStringTable::getInstance()->getString("ParcelMediaUpdate"); +char const* const _PREHASH_NoticeID = LLMessageStringTable::getInstance()->getString("NoticeID"); +char const* const _PREHASH_GridX = LLMessageStringTable::getInstance()->getString("GridX"); +char const* const _PREHASH_GridY = LLMessageStringTable::getInstance()->getString("GridY"); +char const* const _PREHASH_Title = LLMessageStringTable::getInstance()->getString("Title"); +char const* const _PREHASH_AuctionID = LLMessageStringTable::getInstance()->getString("AuctionID"); +char const* const _PREHASH_VoteType = LLMessageStringTable::getInstance()->getString("VoteType"); +char const* const _PREHASH_CategoryID = LLMessageStringTable::getInstance()->getString("CategoryID"); +char const* const _PREHASH_Token = LLMessageStringTable::getInstance()->getString("Token"); +char const* const _PREHASH_AggregatePerms = LLMessageStringTable::getInstance()->getString("AggregatePerms"); +char const* const _PREHASH_ObjectSelect = LLMessageStringTable::getInstance()->getString("ObjectSelect"); +char const* const _PREHASH_ForceObjectSelect = LLMessageStringTable::getInstance()->getString("ForceObjectSelect"); +char const* const _PREHASH_Price = LLMessageStringTable::getInstance()->getString("Price"); +char const* const _PREHASH_SunDirection = LLMessageStringTable::getInstance()->getString("SunDirection"); +char const* const _PREHASH_FromName = LLMessageStringTable::getInstance()->getString("FromName"); +char const* const _PREHASH_ChangeInventoryItemFlags = LLMessageStringTable::getInstance()->getString("ChangLLInventoryItemFlags"); +char const* const _PREHASH_Force = LLMessageStringTable::getInstance()->getString("Force"); +char const* const _PREHASH_TransactionBlock = LLMessageStringTable::getInstance()->getString("TransactionBlock"); +char const* const _PREHASH_PowersMask = LLMessageStringTable::getInstance()->getString("PowersMask"); +char const* const _PREHASH_Stamp = LLMessageStringTable::getInstance()->getString("Stamp"); +char const* const _PREHASH_TotalCredits = LLMessageStringTable::getInstance()->getString("TotalCredits"); +char const* const _PREHASH_State = LLMessageStringTable::getInstance()->getString("State"); +char const* const _PREHASH_TextureIndex = LLMessageStringTable::getInstance()->getString("TextureIndex"); +char const* const _PREHASH_InviteeID = LLMessageStringTable::getInstance()->getString("InviteeID"); +char const* const _PREHASH_ParcelReclaim = LLMessageStringTable::getInstance()->getString("ParcelReclaim"); +char const* const _PREHASH_Money = LLMessageStringTable::getInstance()->getString("Money"); +char const* const _PREHASH_PathTwist = LLMessageStringTable::getInstance()->getString("PathTwist"); +char const* const _PREHASH_AuthBuyerID = LLMessageStringTable::getInstance()->getString("AuthBuyerID"); +char const* const _PREHASH_Color = LLMessageStringTable::getInstance()->getString("Color"); +char const* const _PREHASH_SourceType = LLMessageStringTable::getInstance()->getString("SourceType"); +char const* const _PREHASH_World = LLMessageStringTable::getInstance()->getString("World"); +char const* const _PREHASH_QueryData = LLMessageStringTable::getInstance()->getString("QueryData"); +char const* const _PREHASH_Users = LLMessageStringTable::getInstance()->getString("Users"); +char const* const _PREHASH_SysOS = LLMessageStringTable::getInstance()->getString("SysOS"); +char const* const _PREHASH_Notes = LLMessageStringTable::getInstance()->getString("Notes"); +char const* const _PREHASH_AvatarID = LLMessageStringTable::getInstance()->getString("AvatarID"); +char const* const _PREHASH_FounderID = LLMessageStringTable::getInstance()->getString("FounderID"); +char const* const _PREHASH_EndPointID = LLMessageStringTable::getInstance()->getString("EndPointID"); +char const* const _PREHASH_LocationLookAt = LLMessageStringTable::getInstance()->getString("LocationLookAt"); +char const* const _PREHASH_Sound = LLMessageStringTable::getInstance()->getString("Sound"); +char const* const _PREHASH_Cover = LLMessageStringTable::getInstance()->getString("Cover"); +char const* const _PREHASH_TotalObjectCount = LLMessageStringTable::getInstance()->getString("TotalObjectCount"); +char const* const _PREHASH_TextureEntry = LLMessageStringTable::getInstance()->getString("TextureEntry"); +char const* const _PREHASH_SquareMetersCommitted = LLMessageStringTable::getInstance()->getString("SquareMetersCommitted"); +char const* const _PREHASH_ChannelID = LLMessageStringTable::getInstance()->getString("ChannelID"); +char const* const _PREHASH_Dwell = LLMessageStringTable::getInstance()->getString("Dwell"); +char const* const _PREHASH_North = LLMessageStringTable::getInstance()->getString("North"); +char const* const _PREHASH_AgentUpdate = LLMessageStringTable::getInstance()->getString("AgentUpdate"); +char const* const _PREHASH_PickGodDelete = LLMessageStringTable::getInstance()->getString("PickGodDelete"); +char const* const _PREHASH_HostName = LLMessageStringTable::getInstance()->getString("HostName"); +char const* const _PREHASH_PriceParcelClaim = LLMessageStringTable::getInstance()->getString("PriceParcelClaim"); +char const* const _PREHASH_ParcelClaim = LLMessageStringTable::getInstance()->getString("ParcelClaim"); +char const* const _PREHASH_AgentPowers = LLMessageStringTable::getInstance()->getString("AgentPowers"); +char const* const _PREHASH_ProfileHollow = LLMessageStringTable::getInstance()->getString("ProfileHollow"); +char const* const _PREHASH_GroupRoleChanges = LLMessageStringTable::getInstance()->getString("GroupRoleChanges"); +char const* const _PREHASH_Count = LLMessageStringTable::getInstance()->getString("Count"); +char const* const _PREHASH_South = LLMessageStringTable::getInstance()->getString("South"); +char const* const _PREHASH_ObjectUpdateCompressed = LLMessageStringTable::getInstance()->getString("ObjectUpdateCompressed"); +char const* const _PREHASH_MuteFlags = LLMessageStringTable::getInstance()->getString("MuteFlags"); +char const* const _PREHASH_Group = LLMessageStringTable::getInstance()->getString("Group"); +char const* const _PREHASH_AgentPause = LLMessageStringTable::getInstance()->getString("AgentPause"); +char const* const _PREHASH_LanguagesText = LLMessageStringTable::getInstance()->getString("LanguagesText"); +char const* const _PREHASH_Error = LLMessageStringTable::getInstance()->getString("Error"); +char const* const _PREHASH_InternalScriptMail = LLMessageStringTable::getInstance()->getString("InternalScriptMail"); +char const* const _PREHASH_FindAgent = LLMessageStringTable::getInstance()->getString("FindAgent"); +char const* const _PREHASH_AgentData = LLMessageStringTable::getInstance()->getString("AgentData"); +char const* const _PREHASH_FolderData = LLMessageStringTable::getInstance()->getString("FolderData"); +char const* const _PREHASH_AssetBlock = LLMessageStringTable::getInstance()->getString("AssetBlock"); +char const* const _PREHASH_AcceptNotices = LLMessageStringTable::getInstance()->getString("AcceptNotices"); +char const* const _PREHASH_SetGroupAcceptNotices = LLMessageStringTable::getInstance()->getString("SetGroupAcceptNotices"); +char const* const _PREHASH_CloseCircuit = LLMessageStringTable::getInstance()->getString("CloseCircuit"); +char const* const _PREHASH_TeleportFinish = LLMessageStringTable::getInstance()->getString("TeleportFinish"); +char const* const _PREHASH_PathRevolutions = LLMessageStringTable::getInstance()->getString("PathRevolutions"); +char const* const _PREHASH_ClassifiedInfoReply = LLMessageStringTable::getInstance()->getString("ClassifiedInfoReply"); +char const* const _PREHASH_ParcelInfoReply = LLMessageStringTable::getInstance()->getString("ParcelInfoReply"); +char const* const _PREHASH_AutosaveData = LLMessageStringTable::getInstance()->getString("AutosaveData"); +char const* const _PREHASH_SetStartLocation = LLMessageStringTable::getInstance()->getString("SetStartLocation"); +char const* const _PREHASH_PassHours = LLMessageStringTable::getInstance()->getString("PassHours"); +char const* const _PREHASH_AttachmentPt = LLMessageStringTable::getInstance()->getString("AttachmentPt"); +char const* const _PREHASH_ParcelFlags = LLMessageStringTable::getInstance()->getString("ParcelFlags"); +char const* const _PREHASH_NumVotes = LLMessageStringTable::getInstance()->getString("NumVotes"); +char const* const _PREHASH_AvatarPickerRequest = LLMessageStringTable::getInstance()->getString("AvatarPickerRequest"); +char const* const _PREHASH_TeleportLocationRequest = LLMessageStringTable::getInstance()->getString("TeleportLocationRequest"); +char const* const _PREHASH_DataHomeLocationRequest = LLMessageStringTable::getInstance()->getString("DataHomeLocationRequest"); +char const* const _PREHASH_EventNotificationAddRequest = LLMessageStringTable::getInstance()->getString("EventNotificationAddRequest"); +char const* const _PREHASH_ParcelDwellRequest = LLMessageStringTable::getInstance()->getString("ParcelDwellRequest"); +char const* const _PREHASH_EventLocationRequest = LLMessageStringTable::getInstance()->getString("EventLocationRequest"); +char const* const _PREHASH_SetStartLocationRequest = LLMessageStringTable::getInstance()->getString("SetStartLocationRequest"); +char const* const _PREHASH_QueryStart = LLMessageStringTable::getInstance()->getString("QueryStart"); +char const* const _PREHASH_EjectData = LLMessageStringTable::getInstance()->getString("EjectData"); +char const* const _PREHASH_AvatarTextureUpdate = LLMessageStringTable::getInstance()->getString("AvatarTextureUpdate"); +char const* const _PREHASH_RPCServerPort = LLMessageStringTable::getInstance()->getString("RPCServerPort"); +char const* const _PREHASH_Bytes = LLMessageStringTable::getInstance()->getString("Bytes"); +char const* const _PREHASH_Extra = LLMessageStringTable::getInstance()->getString("Extra"); +char const* const _PREHASH_ForceScriptControlRelease = LLMessageStringTable::getInstance()->getString("ForceScriptControlRelease"); +char const* const _PREHASH_ParcelRelease = LLMessageStringTable::getInstance()->getString("ParcelRelease"); +char const* const _PREHASH_VFileType = LLMessageStringTable::getInstance()->getString("VFileType"); +char const* const _PREHASH_EjectGroupMemberReply = LLMessageStringTable::getInstance()->getString("EjectGroupMemberReply"); +char const* const _PREHASH_ImageData = LLMessageStringTable::getInstance()->getString("ImageData"); +char const* const _PREHASH_SimulatorViewerTimeMessage = LLMessageStringTable::getInstance()->getString("SimulatorViewerTimeMessage"); +char const* const _PREHASH_Rotation = LLMessageStringTable::getInstance()->getString("Rotation"); +char const* const _PREHASH_Selection = LLMessageStringTable::getInstance()->getString("Selection"); +char const* const _PREHASH_TransactionData = LLMessageStringTable::getInstance()->getString("TransactionData"); +char const* const _PREHASH_OperationData = LLMessageStringTable::getInstance()->getString("OperationData"); +char const* const _PREHASH_ExpirationDate = LLMessageStringTable::getInstance()->getString("ExpirationDate"); +char const* const _PREHASH_ParcelDeedToGroup = LLMessageStringTable::getInstance()->getString("ParcelDeedToGroup"); +char const* const _PREHASH_AvatarPicksReply = LLMessageStringTable::getInstance()->getString("AvatarPicksReply"); +char const* const _PREHASH_GroupTitlesReply = LLMessageStringTable::getInstance()->getString("GroupTitlesReply"); +char const* const _PREHASH_AgentInfo = LLMessageStringTable::getInstance()->getString("AgentInfo"); +char const* const _PREHASH_MoneyTransferBackend = LLMessageStringTable::getInstance()->getString("MoneyTransferBackend"); +char const* const _PREHASH_NextOwnerMask = LLMessageStringTable::getInstance()->getString("NextOwnerMask"); +char const* const _PREHASH_MuteData = LLMessageStringTable::getInstance()->getString("MuteData"); +char const* const _PREHASH_PassPrice = LLMessageStringTable::getInstance()->getString("PassPrice"); +char const* const _PREHASH_SourceID = LLMessageStringTable::getInstance()->getString("SourceID"); +char const* const _PREHASH_ChangeUserRights = LLMessageStringTable::getInstance()->getString("ChangeUserRights"); +char const* const _PREHASH_TeleportFlags = LLMessageStringTable::getInstance()->getString("TeleportFlags"); +char const* const _PREHASH_SlaveParcelData = LLMessageStringTable::getInstance()->getString("SlaveParcelData"); +char const* const _PREHASH_AssetData = LLMessageStringTable::getInstance()->getString("AssetData"); +char const* const _PREHASH_MultipleObjectUpdate = LLMessageStringTable::getInstance()->getString("MultipleObjectUpdate"); +char const* const _PREHASH_ObjectUpdate = LLMessageStringTable::getInstance()->getString("ObjectUpdate"); +char const* const _PREHASH_ImprovedTerseObjectUpdate = LLMessageStringTable::getInstance()->getString("ImprovedTerseObjectUpdate"); +char const* const _PREHASH_ConfirmXferPacket = LLMessageStringTable::getInstance()->getString("ConfirmXferPacket"); +char const* const _PREHASH_StartPingCheck = LLMessageStringTable::getInstance()->getString("StartPingCheck"); +char const* const _PREHASH_SimWideDeletes = LLMessageStringTable::getInstance()->getString("SimWideDeletes"); +char const* const _PREHASH_LandStatReply = LLMessageStringTable::getInstance()->getString("LandStatReply"); +char const* const _PREHASH_IsPhantom = LLMessageStringTable::getInstance()->getString("IsPhantom"); +char const* const _PREHASH_AgentList = LLMessageStringTable::getInstance()->getString("AgentList"); +char const* const _PREHASH_SimApproved = LLMessageStringTable::getInstance()->getString("SimApproved"); +char const* const _PREHASH_RezObject = LLMessageStringTable::getInstance()->getString("RezObject"); +char const* const _PREHASH_TaskLocalID = LLMessageStringTable::getInstance()->getString("TaskLocalID"); +char const* const _PREHASH_ClaimDate = LLMessageStringTable::getInstance()->getString("ClaimDate"); +char const* const _PREHASH_MergeParcel = LLMessageStringTable::getInstance()->getString("MergeParcel"); +char const* const _PREHASH_Priority = LLMessageStringTable::getInstance()->getString("Priority"); +char const* const _PREHASH_QueryText = LLMessageStringTable::getInstance()->getString("QueryText"); +char const* const _PREHASH_GroupNoticeAdd = LLMessageStringTable::getInstance()->getString("GroupNoticeAdd"); +char const* const _PREHASH_ReturnType = LLMessageStringTable::getInstance()->getString("ReturnType"); +char const* const _PREHASH_FetchFolders = LLMessageStringTable::getInstance()->getString("FetchFolders"); +char const* const _PREHASH_SimulatorPublicHostBlock = LLMessageStringTable::getInstance()->getString("SimulatorPublicHostBlock"); +char const* const _PREHASH_HeaderData = LLMessageStringTable::getInstance()->getString("HeaderData"); +char const* const _PREHASH_RequestMultipleObjects = LLMessageStringTable::getInstance()->getString("RequestMultipleObjects"); +char const* const _PREHASH_RetrieveInstantMessages = LLMessageStringTable::getInstance()->getString("RetrieveInstantMessages"); +char const* const _PREHASH_OpenCircuit = LLMessageStringTable::getInstance()->getString("OpenCircuit"); +char const* const _PREHASH_CrossedRegion = LLMessageStringTable::getInstance()->getString("CrossedRegion"); +char const* const _PREHASH_DirGroupsReply = LLMessageStringTable::getInstance()->getString("DirGroupsReply"); +char const* const _PREHASH_AvatarGroupsReply = LLMessageStringTable::getInstance()->getString("AvatarGroupsReply"); +char const* const _PREHASH_EmailMessageReply = LLMessageStringTable::getInstance()->getString("EmailMessageReply"); +char const* const _PREHASH_GroupVoteHistoryItemReply = LLMessageStringTable::getInstance()->getString("GroupVoteHistoryItemReply"); +char const* const _PREHASH_ViewerPosition = LLMessageStringTable::getInstance()->getString("ViewerPosition"); +char const* const _PREHASH_Position = LLMessageStringTable::getInstance()->getString("Position"); +char const* const _PREHASH_ParentEstate = LLMessageStringTable::getInstance()->getString("ParentEstate"); +char const* const _PREHASH_EstateName = LLMessageStringTable::getInstance()->getString("EstateName"); +char const* const _PREHASH_MuteName = LLMessageStringTable::getInstance()->getString("MuteName"); +char const* const _PREHASH_ParcelRename = LLMessageStringTable::getInstance()->getString("ParcelRename"); +char const* const _PREHASH_ViewerFilename = LLMessageStringTable::getInstance()->getString("ViewerFilename"); +char const* const _PREHASH_UserReportInternal = LLMessageStringTable::getInstance()->getString("UserReportInternal"); +char const* const _PREHASH_AvatarPropertiesRequest = LLMessageStringTable::getInstance()->getString("AvatarPropertiesRequest"); +char const* const _PREHASH_ParcelPropertiesRequest = LLMessageStringTable::getInstance()->getString("ParcelPropertiesRequest"); +char const* const _PREHASH_GroupProfileRequest = LLMessageStringTable::getInstance()->getString("GroupProfileRequest"); +char const* const _PREHASH_AgentDataUpdateRequest = LLMessageStringTable::getInstance()->getString("AgentDataUpdateRequest"); +char const* const _PREHASH_PriceObjectScaleFactor = LLMessageStringTable::getInstance()->getString("PriceObjectScaleFactor"); +char const* const _PREHASH_OpenEnrollment = LLMessageStringTable::getInstance()->getString("OpenEnrollment"); +char const* const _PREHASH_GroupData = LLMessageStringTable::getInstance()->getString("GroupData"); +char const* const _PREHASH_RequestGodlikePowers = LLMessageStringTable::getInstance()->getString("RequestGodlikePowers"); +char const* const _PREHASH_GrantGodlikePowers = LLMessageStringTable::getInstance()->getString("GrantGodlikePowers"); +char const* const _PREHASH_TransactionID = LLMessageStringTable::getInstance()->getString("TransactionID"); +char const* const _PREHASH_DestinationID = LLMessageStringTable::getInstance()->getString("DestinationID"); +char const* const _PREHASH_Controls = LLMessageStringTable::getInstance()->getString("Controls"); +char const* const _PREHASH_FirstDetachAll = LLMessageStringTable::getInstance()->getString("FirstDetachAll"); +char const* const _PREHASH_EstateID = LLMessageStringTable::getInstance()->getString("EstateID"); +char const* const _PREHASH_ImprovedInstantMessage = LLMessageStringTable::getInstance()->getString("ImprovedInstantMessage"); +char const* const _PREHASH_CheckParcelSales = LLMessageStringTable::getInstance()->getString("CheckParcelSales"); +char const* const _PREHASH_ParcelSales = LLMessageStringTable::getInstance()->getString("ParcelSales"); +char const* const _PREHASH_CurrentInterval = LLMessageStringTable::getInstance()->getString("CurrentInterval"); +char const* const _PREHASH_PriceRentLight = LLMessageStringTable::getInstance()->getString("PriceRentLight"); +char const* const _PREHASH_MediaAutoScale = LLMessageStringTable::getInstance()->getString("MediaAutoScale"); +char const* const _PREHASH_NeighborBlock = LLMessageStringTable::getInstance()->getString("NeighborBlock"); +char const* const _PREHASH_LayerData = LLMessageStringTable::getInstance()->getString("LayerData"); +char const* const _PREHASH_NVPairData = LLMessageStringTable::getInstance()->getString("NVPairData"); +char const* const _PREHASH_TeleportLocal = LLMessageStringTable::getInstance()->getString("TeleportLocal"); +char const* const _PREHASH_EjecteeID = LLMessageStringTable::getInstance()->getString("EjecteeID"); +char const* const _PREHASH_VoteInitiator = LLMessageStringTable::getInstance()->getString("VoteInitiator"); +char const* const _PREHASH_TypeData = LLMessageStringTable::getInstance()->getString("TypeData"); +char const* const _PREHASH_OwnerIDs = LLMessageStringTable::getInstance()->getString("OwnerIDs"); +char const* const _PREHASH_SystemKickUser = LLMessageStringTable::getInstance()->getString("SystemKickUser"); +char const* const _PREHASH_TransactionTime = LLMessageStringTable::getInstance()->getString("TransactionTime"); +char const* const _PREHASH_TimeToLive = LLMessageStringTable::getInstance()->getString("TimeToLive"); +char const* const _PREHASH_OldAgentID = LLMessageStringTable::getInstance()->getString("OldAgentID"); +char const* const _PREHASH_MusicURL = LLMessageStringTable::getInstance()->getString("MusicURL"); +char const* const _PREHASH_ParcelPrimBonus = LLMessageStringTable::getInstance()->getString("ParcelPrimBonus"); +char const* const _PREHASH_EjectUser = LLMessageStringTable::getInstance()->getString("EjectUser"); +char const* const _PREHASH_CoarseLocationUpdate = LLMessageStringTable::getInstance()->getString("CoarseLocationUpdate"); +char const* const _PREHASH_ChildAgentPositionUpdate = LLMessageStringTable::getInstance()->getString("ChildAgentPositionUpdate"); +char const* const _PREHASH_StoreLocal = LLMessageStringTable::getInstance()->getString("StoreLocal"); +char const* const _PREHASH_GroupName = LLMessageStringTable::getInstance()->getString("GroupName"); +char const* const _PREHASH_PriceParcelRent = LLMessageStringTable::getInstance()->getString("PriceParcelRent"); +char const* const _PREHASH_SimStatus = LLMessageStringTable::getInstance()->getString("SimStatus"); +char const* const _PREHASH_TransactionSuccess = LLMessageStringTable::getInstance()->getString("TransactionSuccess"); +char const* const _PREHASH_LureType = LLMessageStringTable::getInstance()->getString("LureType"); +char const* const _PREHASH_GroupMask = LLMessageStringTable::getInstance()->getString("GroupMask"); +char const* const _PREHASH_SitObject = LLMessageStringTable::getInstance()->getString("SitObject"); +char const* const _PREHASH_Override = LLMessageStringTable::getInstance()->getString("Override"); +char const* const _PREHASH_LocomotionState = LLMessageStringTable::getInstance()->getString("LocomotionState"); +char const* const _PREHASH_PriceUpload = LLMessageStringTable::getInstance()->getString("PriceUpload"); +char const* const _PREHASH_RemoveParcel = LLMessageStringTable::getInstance()->getString("RemoveParcel"); +char const* const _PREHASH_ConfirmAuctionStart = LLMessageStringTable::getInstance()->getString("ConfirmAuctionStart"); +char const* const _PREHASH_RpcScriptRequestInbound = LLMessageStringTable::getInstance()->getString("RpcScriptRequestInbound"); +char const* const _PREHASH_ActiveGroupID = LLMessageStringTable::getInstance()->getString("ActiveGroupID"); +char const* const _PREHASH_ParcelReturnObjects = LLMessageStringTable::getInstance()->getString("ParcelReturnObjects"); +char const* const _PREHASH_TotalObjects = LLMessageStringTable::getInstance()->getString("TotalObjects"); +char const* const _PREHASH_ObjectExtraParams = LLMessageStringTable::getInstance()->getString("ObjectExtraParams"); +char const* const _PREHASH_Questions = LLMessageStringTable::getInstance()->getString("Questions"); +char const* const _PREHASH_TransferAbort = LLMessageStringTable::getInstance()->getString("TransferAbort"); +char const* const _PREHASH_TransferInventory = LLMessageStringTable::getInstance()->getString("TransferInventory"); +char const* const _PREHASH_RayTargetID = LLMessageStringTable::getInstance()->getString("RayTargetID"); +char const* const _PREHASH_ClaimPrice = LLMessageStringTable::getInstance()->getString("ClaimPrice"); +char const* const _PREHASH_ObjectProperties = LLMessageStringTable::getInstance()->getString("ObjectProperties"); +char const* const _PREHASH_ParcelProperties = LLMessageStringTable::getInstance()->getString("ParcelProperties"); +char const* const _PREHASH_EstateOwnerID = LLMessageStringTable::getInstance()->getString("EstateOwnerID"); +char const* const _PREHASH_LogoutRequest = LLMessageStringTable::getInstance()->getString("LogoutRequest"); +char const* const _PREHASH_AssetUploadRequest = LLMessageStringTable::getInstance()->getString("AssetUploadRequest"); +char const* const _PREHASH_TransactionType = LLMessageStringTable::getInstance()->getString("TransactionType"); +char const* const _PREHASH_AvatarPropertiesUpdate = LLMessageStringTable::getInstance()->getString("AvatarPropertiesUpdate"); +char const* const _PREHASH_ParcelPropertiesUpdate = LLMessageStringTable::getInstance()->getString("ParcelPropertiesUpdate"); +char const* const _PREHASH_FetchItems = LLMessageStringTable::getInstance()->getString("FetchItems"); +char const* const _PREHASH_AbortXfer = LLMessageStringTable::getInstance()->getString("AbortXfer"); +char const* const _PREHASH_DeRezAck = LLMessageStringTable::getInstance()->getString("DeRezAck"); +char const* const _PREHASH_TakeControls = LLMessageStringTable::getInstance()->getString("TakeControls"); +char const* const _PREHASH_DirLandReply = LLMessageStringTable::getInstance()->getString("DirLandReply"); +char const* const _PREHASH_MuteType = LLMessageStringTable::getInstance()->getString("MuteType"); +char const* const _PREHASH_IMViaEMail = LLMessageStringTable::getInstance()->getString("IMViaEMail"); +char const* const _PREHASH_RentPrice = LLMessageStringTable::getInstance()->getString("RentPrice"); +char const* const _PREHASH_GenericMessage = LLMessageStringTable::getInstance()->getString("GenericMessage"); +char const* const _PREHASH_ChildAgentAlive = LLMessageStringTable::getInstance()->getString("ChildAgentAlive"); +char const* const _PREHASH_AssetType = LLMessageStringTable::getInstance()->getString("AssetType"); +char const* const _PREHASH_SpawnPointBlock = LLMessageStringTable::getInstance()->getString("SpawnPointBlock"); +char const* const _PREHASH_AttachmentBlock = LLMessageStringTable::getInstance()->getString("AttachmentBlock"); +char const* const _PREHASH_ObjectMaterial = LLMessageStringTable::getInstance()->getString("ObjectMaterial"); +char const* const _PREHASH_OwnerName = LLMessageStringTable::getInstance()->getString("OwnerName"); +char const* const _PREHASH_AvatarNotesReply = LLMessageStringTable::getInstance()->getString("AvatarNotesReply"); +char const* const _PREHASH_CacheID = LLMessageStringTable::getInstance()->getString("CacheID"); +char const* const _PREHASH_OwnerMask = LLMessageStringTable::getInstance()->getString("OwnerMask"); +char const* const _PREHASH_TransferInventoryAck = LLMessageStringTable::getInstance()->getString("TransferInventoryAck"); +char const* const _PREHASH_RegionDenyAgeUnverified = LLMessageStringTable::getInstance()->getString("RegionDenyAgeUnverified"); +char const* const _PREHASH_AgeVerificationBlock = LLMessageStringTable::getInstance()->getString("AgeVerificationBlock"); +char const* const _PREHASH_UCoord = LLMessageStringTable::getInstance()->getString("UCoord"); +char const* const _PREHASH_VCoord = LLMessageStringTable::getInstance()->getString("VCoord"); +char const* const _PREHASH_FaceIndex = LLMessageStringTable::getInstance()->getString("FaceIndex"); +char const* const _PREHASH_StatusData = LLMessageStringTable::getInstance()->getString("StatusData"); +char const* const _PREHASH_ProductSKU = LLMessageStringTable::getInstance()->getString("ProductSKU"); +char const* const _PREHASH_SeeAVs = LLMessageStringTable::getInstance()->getString("SeeAVs"); +char const* const _PREHASH_AnyAVSounds = LLMessageStringTable::getInstance()->getString("AnyAVSounds"); +char const* const _PREHASH_GroupAVSounds = LLMessageStringTable::getInstance()->getString("GroupAVSounds"); diff --git a/indra/llmessage/message_prehash.h b/indra/llmessage/message_prehash.h index 08c74d22da..dd2c2dbd64 100644 --- a/indra/llmessage/message_prehash.h +++ b/indra/llmessage/message_prehash.h @@ -32,1347 +32,1351 @@ */ -extern F32 gPrehashVersionNumber; +extern F32 const gPrehashVersionNumber; -extern char * _PREHASH_X; -extern char * _PREHASH_Y; -extern char * _PREHASH_Z; -extern char * _PREHASH_AddFlags; -extern char * _PREHASH_FailureInfo; -extern char * _PREHASH_MapData; -extern char * _PREHASH_AddItem; -extern char * _PREHASH_MeanCollision; -extern char * _PREHASH_RezScript; -extern char * _PREHASH_AvatarSitResponse; -extern char * _PREHASH_InventoryAssetResponse; -extern char * _PREHASH_KillObject; -extern char * _PREHASH_ProposalID; -extern char * _PREHASH_SerialNum; -extern char * _PREHASH_Duration; -extern char * _PREHASH_ScriptQuestion; -extern char * _PREHASH_AddCircuitCode; -extern char * _PREHASH_UseCircuitCode; -extern char * _PREHASH_ViewerCircuitCode; -extern char * _PREHASH_ScriptAnswerYes; -extern char * _PREHASH_PartnerID; -extern char * _PREHASH_DirLandQuery; -extern char * _PREHASH_TeleportStart; -extern char * _PREHASH_AboutText; -extern char * _PREHASH_VisualParam; -extern char * _PREHASH_GroupPrims; -extern char * _PREHASH_SelectedPrims; -extern char * _PREHASH_ID; -extern char * _PREHASH_UUIDNameRequest; -extern char * _PREHASH_UUIDGroupNameRequest; -extern char * _PREHASH_GroupAccountTransactionsRequest; -extern char * _PREHASH_MapNameRequest; -extern char * _PREHASH_UpdateSimulator; -extern char * _PREHASH_BillableFactor; -extern char * _PREHASH_ObjectBonusFactor; -extern char * _PREHASH_EnableSimulator; -extern char * _PREHASH_DisableSimulator; -extern char * _PREHASH_ConfirmEnableSimulator; -extern char * _PREHASH_LayerType; -extern char * _PREHASH_OwnerRole; -extern char * _PREHASH_ParcelOverlay; -extern char * _PREHASH_GroupOwned; -extern char * _PREHASH_IP; -extern char * _PREHASH_ChatFromViewer; -extern char * _PREHASH_AvgAgentsInView; -extern char * _PREHASH_AgentsInView; -extern char * _PREHASH_GroupTitle; -extern char * _PREHASH_MapLayerReply; -extern char * _PREHASH_CompoundMsgID; -extern char * _PREHASH_CameraConstraint; -extern char * _PREHASH_DownloadTotals; -extern char * _PREHASH_GenCounter; -extern char * _PREHASH_FrozenData; -extern char * _PREHASH_ChildAgentDying; -extern char * _PREHASH_To; -extern char * _PREHASH_CopyInventoryFromNotecard; -extern char * _PREHASH_RezObjectFromNotecard; -extern char * _PREHASH_ParcelDirFeeCurrent; -extern char * _PREHASH_SeedCapability; -extern char * _PREHASH_ObjectDuplicate; -extern char * _PREHASH_InventoryData; -extern char * _PREHASH_ReplyData; -extern char * _PREHASH_ResetList; -extern char * _PREHASH_MediaID; -extern char * _PREHASH_RelatedRights; -extern char * _PREHASH_RedirectGridX; -extern char * _PREHASH_RedirectGridY; -extern char * _PREHASH_TransferID; -extern char * _PREHASH_TexturesChanged; -extern char * _PREHASH_UserLookAt; -extern char * _PREHASH_TestBlock1; -extern char * _PREHASH_SensedData; -extern char * _PREHASH_UpdateBlock; -extern char * _PREHASH_ClassifiedGodDelete; -extern char * _PREHASH_ObjectGrabUpdate; -extern char * _PREHASH_LocationPos; -extern char * _PREHASH_TaxDate; -extern char * _PREHASH_StartDateTime; -extern char * _PREHASH_ObjectUpdateCached; -extern char * _PREHASH_Packets; -extern char * _PREHASH_FailureType; -extern char * _PREHASH_UpdateGroupInfo; -extern char * _PREHASH_ObjectPermissions; -extern char * _PREHASH_RevokePermissions; -extern char * _PREHASH_UpdateFlags; -extern char * _PREHASH_ObjectExportSelected; -extern char * _PREHASH_RezSelected; -extern char * _PREHASH_AutoPilot; -extern char * _PREHASH_UpdateMuteListEntry; -extern char * _PREHASH_RemoveMuteListEntry; -extern char * _PREHASH_SetSimStatusInDatabase; -extern char * _PREHASH_SetSimPresenceInDatabase; -extern char * _PREHASH_CameraProperty; -extern char * _PREHASH_BrushSize; -extern char * _PREHASH_SimulatorSetMap; -extern char * _PREHASH_RegionPresenceRequestByRegionID; -extern char * _PREHASH_ParcelObjectOwnersReply; -extern char * _PREHASH_GroupMembersReply; -extern char * _PREHASH_GroupRoleMembersReply; -extern char * _PREHASH_RequestRegionInfo; -extern char * _PREHASH_AABBMax; -extern char * _PREHASH_RequestPayPrice; -extern char * _PREHASH_SimulatorPresentAtLocation; -extern char * _PREHASH_AgentRequestSit; -extern char * _PREHASH_AABBMin; -extern char * _PREHASH_ClassifiedFlags; -extern char * _PREHASH_ControlFlags; -extern char * _PREHASH_TeleportRequest; -extern char * _PREHASH_ScriptTeleportRequest; -extern char * _PREHASH_EstateCovenantRequest; -extern char * _PREHASH_DateUTC; -extern char * _PREHASH_TaskIDs; -extern char * _PREHASH_RequestResult; -extern char * _PREHASH_CanAcceptAgents; -extern char * _PREHASH_ObjectSaleInfo; -extern char * _PREHASH_KillChildAgents; -extern char * _PREHASH_Balance; -extern char * _PREHASH_DerezContainer; -extern char * _PREHASH_ObjectData; -extern char * _PREHASH_CameraAtAxis; -extern char * _PREHASH_InfoBlock; -extern char * _PREHASH_OwnershipCost; -extern char * _PREHASH_AvatarNotesUpdate; -extern char * _PREHASH_PID; -extern char * _PREHASH_DirPopularReply; -extern char * _PREHASH_TerrainHeightRange00; -extern char * _PREHASH_SimData; -extern char * _PREHASH_TerrainHeightRange01; -extern char * _PREHASH_TerrainHeightRange10; -extern char * _PREHASH_TerrainHeightRange11; -extern char * _PREHASH_UpdateInventoryItem; -extern char * _PREHASH_UpdateCreateInventoryItem; -extern char * _PREHASH_MoveInventoryItem; -extern char * _PREHASH_CopyInventoryItem; -extern char * _PREHASH_LinkInventoryItem; -extern char * _PREHASH_RemoveInventoryItem; -extern char * _PREHASH_CreateInventoryItem; -extern char * _PREHASH_PathTwistBegin; -extern char * _PREHASH_CRC; -extern char * _PREHASH_AttachmentPoint; -extern char * _PREHASH_TelehubBlock; -extern char * _PREHASH_FOVBlock; -extern char * _PREHASH_StartLocationData; -extern char * _PREHASH_PositionData; -extern char * _PREHASH_TimeSinceLast; -extern char * _PREHASH_MapImage; -extern char * _PREHASH_Objects; -extern char * _PREHASH_URL; -extern char * _PREHASH_CreationDate; -extern char * _PREHASH_JointPivot; -extern char * _PREHASH_FPS; -extern char * _PREHASH_HasTelehub; -extern char * _PREHASH_PathEnd; -extern char * _PREHASH_ScriptDataReply; -extern char * _PREHASH_MapBlockReply; -extern char * _PREHASH_PropertiesData; -extern char * _PREHASH_ViewerEffect; -extern char * _PREHASH_FreezeUser; -extern char * _PREHASH_OwnerPrims; -extern char * _PREHASH_ObjectGrab; -extern char * _PREHASH_ToAgentID; -extern char * _PREHASH_SimulatorMapUpdate; -extern char * _PREHASH_TransferPacket; -extern char * _PREHASH_ObjectName; -extern char * _PREHASH_GroupPowers; -extern char * _PREHASH_OriginalName; -extern char * _PREHASH_CompletePingCheck; -extern char * _PREHASH_OnlineStatus; -extern char * _PREHASH_ObjectDrop; -extern char * _PREHASH_UseBigPackets; -extern char * _PREHASH_GroupNoticesListReply; -extern char * _PREHASH_ParcelAccessListReply; -extern char * _PREHASH_RpcChannelReply; -extern char * _PREHASH_RegionPresenceResponse; -extern char * _PREHASH_CharterMember; -extern char * _PREHASH_EdgeData; -extern char * _PREHASH_NameData; -extern char * _PREHASH_RegionPushOverride; -extern char * _PREHASH_SimName; -extern char * _PREHASH_UserReport; -extern char * _PREHASH_DownloadPriority; -extern char * _PREHASH_ToAgentId; -extern char * _PREHASH_DirPopularQuery; -extern char * _PREHASH_Mag; -extern char * _PREHASH_ParcelPropertiesRequestByID; -extern char * _PREHASH_ObjectLink; -extern char * _PREHASH_RpcScriptReplyInbound; -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_FLAboutText; -extern char * _PREHASH_RegionHandshakeReply; -extern char * _PREHASH_GroupActiveProposalItemReply; -extern char * _PREHASH_MapItemReply; -extern char * _PREHASH_Seconds; -extern char * _PREHASH_UpdateUserInfo; -extern char * _PREHASH_AggregatePermTexturesOwner; -extern char * _PREHASH_Set; -extern char * _PREHASH_NewName; -extern char * _PREHASH_Key; -extern char * _PREHASH_AgentID; -extern char * _PREHASH_EventNotificationRemoveRequest; -extern char * _PREHASH_NewFolderID; -extern char * _PREHASH_Arc; -extern char * _PREHASH_RegionX; -extern char * _PREHASH_RegionY; -extern char * _PREHASH_RequestData; -extern char * _PREHASH_Msg; -extern char * _PREHASH_Top; -extern char * _PREHASH_MiscStats; -extern char * _PREHASH_ImageID; -extern char * _PREHASH_DataPacket; -extern char * _PREHASH_You; -extern char * _PREHASH_ScriptControlChange; -extern char * _PREHASH_LoadURL; -extern char * _PREHASH_SetCPURatio; -extern char * _PREHASH_NameValueData; -extern char * _PREHASH_AtomicPassObject; -extern char * _PREHASH_ErrorMessage; -extern char * _PREHASH_ViewerFrozenMessage; -extern char * _PREHASH_HealthMessage; -extern char * _PREHASH_LogTextMessage; -extern char * _PREHASH_TimeDilation; -extern char * _PREHASH_RemoveContribution; -extern char * _PREHASH_Contribution; -extern char * _PREHASH_SetGroupContribution; -extern char * _PREHASH_Offline; -extern char * _PREHASH_AgentIsNowWearing; -extern char * _PREHASH_Members; -extern char * _PREHASH_FailedResends; -extern char * _PREHASH_SecPerDay; -extern char * _PREHASH_CameraCenter; -extern char * _PREHASH_CameraLeftAxis; -extern char * _PREHASH_ExBlock; -extern char * _PREHASH_Channel; -extern char * _PREHASH_NetTest; -extern char * _PREHASH_DiscardLevel; -extern char * _PREHASH_LayerID; -extern char * _PREHASH_GrabOffset; -extern char * _PREHASH_SimPort; -extern char * _PREHASH_PricePerMeter; -extern char * _PREHASH_RegionFlags; -extern char * _PREHASH_VoteResult; -extern char * _PREHASH_ParcelDirFeeEstimate; -extern char * _PREHASH_ModifyBlock; -extern char * _PREHASH_InventoryBlock; -extern char * _PREHASH_ReplyBlock; -extern char * _PREHASH_ValidUntil; -extern char * _PREHASH_VelocityInterpolateOn; -extern char * _PREHASH_ClassifiedDelete; -extern char * _PREHASH_RegionDenyAnonymous; -extern char * _PREHASH_FLImageID; -extern char * _PREHASH_AllowPublish; -extern char * _PREHASH_SitName; -extern char * _PREHASH_RegionsVisited; -extern char * _PREHASH_DirClassifiedReply; -extern char * _PREHASH_AvatarClassifiedReply; -extern char * _PREHASH_MediaURL; -extern char * _PREHASH_CompleteAgentMovement; -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_DuplicateFlags; -extern char * _PREHASH_RegionInfo2; -extern char * _PREHASH_TextColor; -extern char * _PREHASH_SlaveID; -extern char * _PREHASH_Charter; -extern char * _PREHASH_AlertData; -extern char * _PREHASH_AlertInfo; -extern char * _PREHASH_TargetBlock; -extern char * _PREHASH_CheckParcelAuctions; -extern char * _PREHASH_ParcelAuctions; -extern char * _PREHASH_OwnerIsGroup; -extern char * _PREHASH_NameValuePair; -extern char * _PREHASH_RemoveNameValuePair; -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_AggregatePermInventory; -extern char * _PREHASH_GroupAccountTransactionsReply; -extern char * _PREHASH_SimulatorInfo; -extern char * _PREHASH_WearableData; -extern char * _PREHASH_Enabled; -extern char * _PREHASH_Savings; -extern char * _PREHASH_SimulatorLoad; -extern char * _PREHASH_InternalRegionIP; -extern char * _PREHASH_ExternalRegionIP; -extern char * _PREHASH_TotalPairs; -extern char * _PREHASH_CreateGroupRequest; -extern char * _PREHASH_JoinGroupRequest; -extern char * _PREHASH_LeaveGroupRequest; -extern char * _PREHASH_InviteGroupRequest; -extern char * _PREHASH_LiveHelpGroupRequest; -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_ChangedGrid; -extern char * _PREHASH_AgentDropGroup; -extern char * _PREHASH_Details; -extern char * _PREHASH_LocationX; -extern char * _PREHASH_SaleType; -extern char * _PREHASH_LocationY; -extern char * _PREHASH_LocationZ; -extern char * _PREHASH_EconomyData; -extern char * _PREHASH_HeadRotation; -extern char * _PREHASH_DeleteOnCompletion; -extern char * _PREHASH_PublicPort; -extern char * _PREHASH_DirClassifiedQuery; -extern char * _PREHASH_CallbackID; -extern char * _PREHASH_RequestParcelTransfer; -extern char * _PREHASH_RoleCount; -extern char * _PREHASH_ObjectCapacity; -extern char * _PREHASH_RequestID; -extern char * _PREHASH_RequestXfer; -extern char * _PREHASH_ObjectTaxCurrent; -extern char * _PREHASH_LightTaxCurrent; -extern char * _PREHASH_LandTaxCurrent; -extern char * _PREHASH_GroupTaxCurrent; -extern char * _PREHASH_FetchInventoryDescendents; -extern char * _PREHASH_InventoryDescendents; -extern char * _PREHASH_Descendents; -extern char * _PREHASH_PurgeInventoryDescendents; -extern char * _PREHASH_ShowDir; -extern char * _PREHASH_IsOwner; -extern char * _PREHASH_Timestamp; -extern char * _PREHASH_GlobalPos; -extern char * _PREHASH_GrabOffsetInitial; -extern char * _PREHASH_IsTrial; -extern char * _PREHASH_ObjectDuplicateOnRay; -extern char * _PREHASH_GroupMembershipCount; -extern char * _PREHASH_MethodData; -extern char * _PREHASH_ActivateGestures; -extern char * _PREHASH_DeactivateGestures; -extern char * _PREHASH_ProposalData; -extern char * _PREHASH_PosGlobal; -extern char * _PREHASH_SearchID; -extern char * _PREHASH_RezMultipleAttachmentsFromInv; -extern char * _PREHASH_SearchName; -extern char * _PREHASH_VersionString; -extern char * _PREHASH_CreateGroupReply; -extern char * _PREHASH_LeaveGroupReply; -extern char * _PREHASH_ActualArea; -extern char * _PREHASH_Message; -extern char * _PREHASH_ClickAction; -extern char * _PREHASH_AssetUploadComplete; -extern char * _PREHASH_RequestType; -extern char * _PREHASH_UUID; -extern char * _PREHASH_BaseMask; -extern char * _PREHASH_NetBlock; -extern char * _PREHASH_GlobalX; -extern char * _PREHASH_GlobalY; -extern char * _PREHASH_CopyRotates; -extern char * _PREHASH_KickUserAck; -extern char * _PREHASH_TopPick; -extern char * _PREHASH_SessionID; -extern char * _PREHASH_GlobalZ; -extern char * _PREHASH_DeclineFriendship; -extern char * _PREHASH_FormFriendship; -extern char * _PREHASH_TerminateFriendship; -extern char * _PREHASH_TaskData; -extern char * _PREHASH_SimWideMaxPrims; -extern char * _PREHASH_TotalPrims; -extern char * _PREHASH_ProfileBegin; -extern char * _PREHASH_Request; -extern char * _PREHASH_GroupAccountDetailsRequest; -extern char * _PREHASH_GroupActiveProposalsRequest; -extern char * _PREHASH_StringValue; -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_PickInfoUpdate; -extern char * _PREHASH_PickDelete; -extern char * _PREHASH_ScriptReset; -extern char * _PREHASH_Requester; -extern char * _PREHASH_ForSale; -extern char * _PREHASH_NearestLandingRegionReply; -extern char * _PREHASH_ParcelID; -extern char * _PREHASH_Godlike; -extern char * _PREHASH_TotalDebits; -extern char * _PREHASH_Direction; -extern char * _PREHASH_HealthData; -extern char * _PREHASH_LeftAxis; -extern char * _PREHASH_LocationBlock; -extern char * _PREHASH_ObjectImage; -extern char * _PREHASH_TerrainStartHeight00; -extern char * _PREHASH_TerrainStartHeight01; -extern char * _PREHASH_TerrainStartHeight10; -extern char * _PREHASH_TerrainStartHeight11; -extern char * _PREHASH_WaterHeight; -extern char * _PREHASH_FetchInventoryReply; -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_ObjectCount; -extern char * _PREHASH_RegionPresenceRequestByHandle; -extern char * _PREHASH_RezSingleAttachmentFromInv; -extern char * _PREHASH_ChildAgentUpdate; -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_UpdateParcel; -extern char * _PREHASH_SetAlwaysRun; -extern char * _PREHASH_NVPair; -extern char * _PREHASH_SearchType; -extern char * _PREHASH_ObjectSpinStart; -extern char * _PREHASH_UseEstateSun; -extern char * _PREHASH_RegionID; -extern char * _PREHASH_AbuseRegionID; -extern char * _PREHASH_Creator; -extern char * _PREHASH_ProposalText; -extern char * _PREHASH_DirEventsReply; -extern char * _PREHASH_EventInfoReply; -extern char * _PREHASH_UserInfoReply; -extern char * _PREHASH_PathRadiusOffset; -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_LandmarkID; -extern char * _PREHASH_InitiateDownload; -extern char * _PREHASH_Name; -extern char * _PREHASH_OtherCleanTime; -extern char * _PREHASH_ParcelSetOtherCleanTime; -extern char * _PREHASH_TeleportPriceExponent; -extern char * _PREHASH_Gain; -extern char * _PREHASH_PacketAck; -extern char * _PREHASH_PathSkew; -extern char * _PREHASH_SimulatorShutdownRequest; -extern char * _PREHASH_NearestLandingRegionRequest; -extern char * _PREHASH_OtherID; -extern char * _PREHASH_MemberID; -extern char * _PREHASH_MapLayerRequest; -extern char * _PREHASH_ObjectScale; -extern char * _PREHASH_TargetIP; -extern char * _PREHASH_Redo; -extern char * _PREHASH_MoneyBalance; -extern char * _PREHASH_TrackAgent; -extern char * _PREHASH_MaxX; -extern char * _PREHASH_Data; -extern char * _PREHASH_MaxY; -extern char * _PREHASH_TextureAnim; -extern char * _PREHASH_ReturnIDs; -extern char * _PREHASH_Date; -extern char * _PREHASH_AgentWearablesUpdate; -extern char * _PREHASH_AgentDataUpdate; -extern char * _PREHASH_GroupDataUpdate; -extern char * _PREHASH_Hash; -extern char * _PREHASH_AgentGroupDataUpdate; -extern char * _PREHASH_Left; -extern char * _PREHASH_Mask; -extern char * _PREHASH_ForceMouselook; -extern char * _PREHASH_Success; -extern char * _PREHASH_ObjectGroup; -extern char * _PREHASH_SunHour; -extern char * _PREHASH_MinX; -extern char * _PREHASH_ScriptSensorReply; -extern char * _PREHASH_MinY; -extern char * _PREHASH_Command; -extern char * _PREHASH_Desc; -extern char * _PREHASH_AttachmentNeedsSave; -extern char * _PREHASH_HistoryItemData; -extern char * _PREHASH_AgentCachedTexture; -extern char * _PREHASH_Subject; -extern char * _PREHASH_East; -extern char * _PREHASH_QueryReplies; -extern char * _PREHASH_ObjectCategory; -extern char * _PREHASH_Time; -extern char * _PREHASH_CreateLandmarkForEvent; -extern char * _PREHASH_ParentID; -extern char * _PREHASH_Ping; -extern char * _PREHASH_Perp; -extern char * _PREHASH_Code; -extern char * _PREHASH_InvType; -extern char * _PREHASH_AgentFOV; -extern char * _PREHASH_Audible; -extern char * _PREHASH_AuctionData; -extern char * _PREHASH_IDBlock; -extern char * _PREHASH_West; -extern char * _PREHASH_Undo; -extern char * _PREHASH_TotalNumItems; -extern char * _PREHASH_Info; -extern char * _PREHASH_Area; -extern char * _PREHASH_SimCrashed; -extern char * _PREHASH_Text; -extern char * _PREHASH_PriceGroupCreate; -extern char * _PREHASH_ObjectShape; -extern char * _PREHASH_GroupRoleDataReply; -extern char * _PREHASH_MuteCRC; -extern char * _PREHASH_Size; -extern char * _PREHASH_FromAddress; -extern char * _PREHASH_Body; -extern char * _PREHASH_FileData; -extern char * _PREHASH_List; -extern char * _PREHASH_KickUser; -extern char * _PREHASH_OtherPrims; -extern char * _PREHASH_RunTime; -extern char * _PREHASH_GrantUserRights; -extern char * _PREHASH_RpcScriptRequestInboundForward; -extern char * _PREHASH_More; -extern char * _PREHASH_Majority; -extern char * _PREHASH_MetersTraveled; -extern char * _PREHASH_Stat; -extern char * _PREHASH_SoundID; -extern char * _PREHASH_Item; -extern char * _PREHASH_User; -extern char * _PREHASH_Prey; -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_ProfileCurve; -extern char * _PREHASH_ParcelAccessListUpdate; -extern char * _PREHASH_MuteListUpdate; -extern char * _PREHASH_SendPacket; -extern char * _PREHASH_SendXferPacket; -extern char * _PREHASH_RegionDenyIdentified; -extern char * _PREHASH_NotecardItemID; -extern char * _PREHASH_LastName; -extern char * _PREHASH_From; -extern char * _PREHASH_RoleChange; -extern char * _PREHASH_Port; -extern char * _PREHASH_MemberTitle; -extern char * _PREHASH_LogParcelChanges; -extern char * _PREHASH_AgentCachedTextureResponse; -extern char * _PREHASH_DeRezObject; -extern char * _PREHASH_IsTemporary; -extern char * _PREHASH_InsigniaID; -extern char * _PREHASH_CheckFlags; -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_RequestBlock; -extern char * _PREHASH_GrantData; -extern char * _PREHASH_DetachAttachmentIntoInv; -extern char * _PREHASH_ParcelDisableObjects; -extern char * _PREHASH_Sections; -extern char * _PREHASH_GodLevel; -extern char * _PREHASH_PayPriceReply; -extern char * _PREHASH_QueryID; -extern char * _PREHASH_CameraEyeOffset; -extern char * _PREHASH_AgentPosition; -extern char * _PREHASH_GrabPosition; -extern char * _PREHASH_OnlineNotification; -extern char * _PREHASH_OfflineNotification; -extern char * _PREHASH_SendPostcard; -extern char * _PREHASH_RequestFlags; -extern char * _PREHASH_GroupAccountSummaryRequest; -extern char * _PREHASH_GroupVoteHistoryRequest; -extern char * _PREHASH_ParamValue; -extern char * _PREHASH_MaxAgents; -extern char * _PREHASH_CreateNewOutfitAttachments; -extern char * _PREHASH_RegionHandle; -extern char * _PREHASH_TeleportProgress; -extern char * _PREHASH_AgentQuitCopy; -extern char * _PREHASH_AvatarInterestsUpdate; -extern char * _PREHASH_GroupNoticeID; -extern char * _PREHASH_ParcelName; -extern char * _PREHASH_PriceObjectRent; -extern char * _PREHASH_OfferCallingCard; -extern char * _PREHASH_AcceptCallingCard; -extern char * _PREHASH_DeclineCallingCard; -extern char * _PREHASH_AgentAccess; -extern char * _PREHASH_AgentLegacyAccess; -extern char * _PREHASH_AgentMaxAccess; -extern char * _PREHASH_DataHomeLocationReply; -extern char * _PREHASH_EventLocationReply; -extern char * _PREHASH_TerseDateID; -extern char * _PREHASH_ObjectOwner; -extern char * _PREHASH_AssetID; -extern char * _PREHASH_AlertMessage; -extern char * _PREHASH_AgentAlertMessage; -extern char * _PREHASH_EstateOwnerMessage; -extern char * _PREHASH_ParcelMediaCommandMessage; -extern char * _PREHASH_Auction; -extern char * _PREHASH_Category; -extern char * _PREHASH_FilePath; -extern char * _PREHASH_ItemFlags; -extern char * _PREHASH_Invoice; -extern char * _PREHASH_IntervalDays; -extern char * _PREHASH_PathScaleX; -extern char * _PREHASH_FromTaskID; -extern char * _PREHASH_PathScaleY; -extern char * _PREHASH_TimeInfo; -extern char * _PREHASH_PublicCount; -extern char * _PREHASH_ParcelJoin; -extern char * _PREHASH_GroupRolesCount; -extern char * _PREHASH_SimulatorBlock; -extern char * _PREHASH_GroupID; -extern char * _PREHASH_AgentVel; -extern char * _PREHASH_RequestImage; -extern char * _PREHASH_NetStats; -extern char * _PREHASH_AgentPos; -extern char * _PREHASH_AgentSit; -extern char * _PREHASH_Material; -extern char * _PREHASH_ObjectDeGrab; -extern char * _PREHASH_VelocityInterpolateOff; -extern char * _PREHASH_AuthorizedBuyerID; -extern char * _PREHASH_AvatarPropertiesReply; -extern char * _PREHASH_GroupProfileReply; -extern char * _PREHASH_SimOwner; -extern char * _PREHASH_SalePrice; -extern char * _PREHASH_Animation; -extern char * _PREHASH_OwnerID; -extern char * _PREHASH_NearestLandingRegionUpdated; -extern char * _PREHASH_PassToAgent; -extern char * _PREHASH_PreyAgent; -extern char * _PREHASH_SimStats; -extern char * _PREHASH_LogoutReply; -extern char * _PREHASH_FeatureDisabled; -extern char * _PREHASH_PhysicalAvatarEventList; -extern char * _PREHASH_ObjectLocalID; -extern char * _PREHASH_Dropped; -extern char * _PREHASH_WebProfilesDisabled; -extern char * _PREHASH_Destination; -extern char * _PREHASH_MasterID; -extern char * _PREHASH_TransferData; -extern char * _PREHASH_WantToMask; -extern char * _PREHASH_ParcelSelectObjects; -extern char * _PREHASH_ExtraParams; -extern char * _PREHASH_CreatorID; -extern char * _PREHASH_Summary; -extern char * _PREHASH_BuyObjectInventory; -extern char * _PREHASH_FetchInventory; -extern char * _PREHASH_InventoryID; -extern char * _PREHASH_PacketNumber; -extern char * _PREHASH_SetFollowCamProperties; -extern char * _PREHASH_ClearFollowCamProperties; -extern char * _PREHASH_SequenceID; -extern char * _PREHASH_DataServerLogout; -extern char * _PREHASH_NameValue; -extern char * _PREHASH_PathShearX; -extern char * _PREHASH_PathShearY; -extern char * _PREHASH_Velocity; -extern char * _PREHASH_SecPerYear; -extern char * _PREHASH_FirstName; -extern char * _PREHASH_AttachedSoundGainChange; -extern char * _PREHASH_LocationID; -extern char * _PREHASH_Running; -extern char * _PREHASH_AgentThrottle; -extern char * _PREHASH_NeighborList; -extern char * _PREHASH_PathTaperX; -extern char * _PREHASH_PathTaperY; -extern char * _PREHASH_AgentRelated; -extern char * _PREHASH_GranterBlock; -extern char * _PREHASH_UseCachedMuteList; -extern char * _PREHASH_FailStats; -extern char * _PREHASH_Tempfile; -extern char * _PREHASH_BuyerID; -extern char * _PREHASH_DirPeopleReply; -extern char * _PREHASH_TransferInfo; -extern char * _PREHASH_AvatarPickerRequestBackend; -extern char * _PREHASH_AvatarPropertiesRequestBackend; -extern char * _PREHASH_UpdateData; -extern char * _PREHASH_SimFPS; -extern char * _PREHASH_ReporterID; -extern char * _PREHASH_ButtonLabel; -extern char * _PREHASH_GranterID; -extern char * _PREHASH_WantToText; -extern char * _PREHASH_ReportType; -extern char * _PREHASH_SimulatorReady; -extern char * _PREHASH_DataBlock; -extern char * _PREHASH_AnimationSourceList; -extern char * _PREHASH_SubscribeLoad; -extern char * _PREHASH_UnsubscribeLoad; -extern char * _PREHASH_Packet; -extern char * _PREHASH_UndoLand; -extern char * _PREHASH_SimAccess; -extern char * _PREHASH_AbuserID; -extern char * _PREHASH_MembershipFee; -extern char * _PREHASH_InviteGroupResponse; -extern char * _PREHASH_CreateInventoryFolder; -extern char * _PREHASH_UpdateInventoryFolder; -extern char * _PREHASH_MoveInventoryFolder; -extern char * _PREHASH_RemoveInventoryFolder; -extern char * _PREHASH_MoneyData; -extern char * _PREHASH_ObjectDeselect; -extern char * _PREHASH_NewAssetID; -extern char * _PREHASH_ObjectAdd; -extern char * _PREHASH_RayEndIsIntersection; -extern char * _PREHASH_CompleteAuction; -extern char * _PREHASH_CircuitCode; -extern char * _PREHASH_AgentMovementComplete; -extern char * _PREHASH_ViewerIP; -extern char * _PREHASH_Header; -extern char * _PREHASH_GestureFlags; -extern char * _PREHASH_XferID; -extern char * _PREHASH_StatValue; -extern char * _PREHASH_TaskID; -extern char * _PREHASH_PickID; -extern char * _PREHASH_RayEnd; -extern char * _PREHASH_Throttles; -extern char * _PREHASH_RebakeAvatarTextures; -extern char * _PREHASH_UpAxis; -extern char * _PREHASH_AgentTextures; -extern char * _PREHASH_NotecardData; -extern char * _PREHASH_Radius; -extern char * _PREHASH_OffCircuit; -extern char * _PREHASH_Access; -extern char * _PREHASH_TitleRoleID; -extern char * _PREHASH_SquareMetersCredit; -extern char * _PREHASH_Filename; -extern char * _PREHASH_ClassifiedInfoRequest; -extern char * _PREHASH_ParcelInfoRequest; -extern char * _PREHASH_ParcelObjectOwnersRequest; -extern char * _PREHASH_TeleportLandmarkRequest; -extern char * _PREHASH_EventInfoRequest; -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_ButtonIndex; -extern char * _PREHASH_GetScriptRunning; -extern char * _PREHASH_SetScriptRunning; -extern char * _PREHASH_Health; -extern char * _PREHASH_CircuitInfo; -extern char * _PREHASH_ObjectBuy; -extern char * _PREHASH_ProfileEnd; -extern char * _PREHASH_Effect; -extern char * _PREHASH_TestMessage; -extern char * _PREHASH_ScriptMailRegistration; -extern char * _PREHASH_AgentSetAppearance; -extern char * _PREHASH_AvatarAppearance; -extern char * _PREHASH_RegionData; -extern char * _PREHASH_RequestingRegionData; -extern char * _PREHASH_LandingRegionData; -extern char * _PREHASH_SitTransform; -extern char * _PREHASH_TerrainBase0; -extern char * _PREHASH_SkillsMask; -extern char * _PREHASH_AtAxis; -extern char * _PREHASH_TerrainBase1; -extern char * _PREHASH_Reason; -extern char * _PREHASH_TerrainBase2; -extern char * _PREHASH_TerrainBase3; -extern char * _PREHASH_Params; -extern char * _PREHASH_PingID; -extern char * _PREHASH_Change; -extern char * _PREHASH_Height; -extern char * _PREHASH_Region; -extern char * _PREHASH_TelehubInfo; -extern char * _PREHASH_StateSave; -extern char * _PREHASH_RoleData; -extern char * _PREHASH_AgentAnimation; -extern char * _PREHASH_AvatarAnimation; -extern char * _PREHASH_LogDwellTime; -extern char * _PREHASH_ParcelGodMarkAsContent; -extern char * _PREHASH_UsePhysics; -extern char * _PREHASH_RegionDenyTransacted; -extern char * _PREHASH_JointType; -extern char * _PREHASH_ObjectTaxEstimate; -extern char * _PREHASH_LightTaxEstimate; -extern char * _PREHASH_LandTaxEstimate; -extern char * _PREHASH_TeleportLandingStatusChanged; -extern char * _PREHASH_GroupTaxEstimate; -extern char * _PREHASH_AvgViewerFPS; -extern char * _PREHASH_Buttons; -extern char * _PREHASH_Sender; -extern char * _PREHASH_Dialog; -extern char * _PREHASH_TargetData; -extern char * _PREHASH_DestID; -extern char * _PREHASH_PricePublicObjectDelete; -extern char * _PREHASH_ObjectDelete; -extern char * _PREHASH_Delete; -extern char * _PREHASH_EventGodDelete; -extern char * _PREHASH_LastTaxDate; -extern char * _PREHASH_MapImageID; -extern char * _PREHASH_EndDateTime; -extern char * _PREHASH_TerrainDetail0; -extern char * _PREHASH_TerrainDetail1; -extern char * _PREHASH_TerrainDetail2; -extern char * _PREHASH_TerrainDetail3; -extern char * _PREHASH_Offset; -extern char * _PREHASH_ObjectDelink; -extern char * _PREHASH_TargetObject; -extern char * _PREHASH_IsEstateManager; -extern char * _PREHASH_CancelAuction; -extern char * _PREHASH_ObjectDetach; -extern char * _PREHASH_Compressed; -extern char * _PREHASH_PathBegin; -extern char * _PREHASH_BypassRaycast; -extern char * _PREHASH_WinnerID; -extern char * _PREHASH_ChannelType; -extern char * _PREHASH_NonExemptMembers; -extern char * _PREHASH_Agents; -extern char * _PREHASH_MemberData; -extern char * _PREHASH_ToGroupID; -extern char * _PREHASH_ImageNotInDatabase; -extern char * _PREHASH_StartDate; -extern char * _PREHASH_AnimID; -extern char * _PREHASH_Serial; -extern char * _PREHASH_AbuseRegionName; -extern char * _PREHASH_ModifyLand; -extern char * _PREHASH_Digest; -extern char * _PREHASH_Victim; -extern char * _PREHASH_Script; -extern char * _PREHASH_PickInfoReply; -extern char * _PREHASH_MoneyBalanceReply; -extern char * _PREHASH_RoutedMoneyBalanceReply; -extern char * _PREHASH_RoleID; -extern char * _PREHASH_RegionInfo; -extern char * _PREHASH_GodUpdateRegionInfo; -extern char * _PREHASH_StartAnim; -extern char * _PREHASH_Action; -extern char * _PREHASH_Location; -extern char * _PREHASH_Rights; -extern char * _PREHASH_SearchDir; -extern char * _PREHASH_TransferRequest; -extern char * _PREHASH_ScriptSensorRequest; -extern char * _PREHASH_MoneyTransferRequest; -extern char * _PREHASH_EjectGroupMemberRequest; -extern char * _PREHASH_SkillsText; -extern char * _PREHASH_Resent; -extern char * _PREHASH_Center; -extern char * _PREHASH_SharedData; -extern char * _PREHASH_PSBlock; -extern char * _PREHASH_UUIDNameBlock; -extern char * _PREHASH_GroupTitleUpdate; -extern char * _PREHASH_Method; -extern char * _PREHASH_TouchName; -extern char * _PREHASH_UpdateType; -extern char * _PREHASH_KickedFromEstateID; -extern char * _PREHASH_CandidateID; -extern char * _PREHASH_ParamData; -extern char * _PREHASH_GodlikeMessage; -extern char * _PREHASH_SystemMessage; -extern char * _PREHASH_BodyRotation; -extern char * _PREHASH_SearchRegions; -extern char * _PREHASH_AnimationData; -extern char * _PREHASH_StatID; -extern char * _PREHASH_ItemID; -extern char * _PREHASH_ScriptDialogReply; -extern char * _PREHASH_RegionIDAndHandleReply; -extern char * _PREHASH_CameraAtOffset; -extern char * _PREHASH_VoteID; -extern char * _PREHASH_ParcelGodForceOwner; -extern char * _PREHASH_Filter; -extern char * _PREHASH_InviteData; -extern char * _PREHASH_PCode; -extern char * _PREHASH_SearchPos; -extern char * _PREHASH_PreyID; -extern char * _PREHASH_TerrainLowerLimit; -extern char * _PREHASH_EventFlags; -extern char * _PREHASH_TallyVotes; -extern char * _PREHASH_Result; -extern char * _PREHASH_LookAt; -extern char * _PREHASH_SearchOrder; -extern char * _PREHASH_PayButton; -extern char * _PREHASH_SelfCount; -extern char * _PREHASH_PacketCount; -extern char * _PREHASH_ParcelBuyPass; -extern char * _PREHASH_OldItemID; -extern char * _PREHASH_RegionPort; -extern char * _PREHASH_PriceEnergyUnit; -extern char * _PREHASH_Bitmap; -extern char * _PREHASH_CacheMissType; -extern char * _PREHASH_VFileID; -extern char * _PREHASH_GroupInsigniaID; -extern char * _PREHASH_Online; -extern char * _PREHASH_KickFlags; -extern char * _PREHASH_CovenantID; -extern char * _PREHASH_SysCPU; -extern char * _PREHASH_EMail; -extern char * _PREHASH_AggregatePermTextures; -extern char * _PREHASH_ChatChannel; -extern char * _PREHASH_ReturnID; -extern char * _PREHASH_ObjectAttach; -extern char * _PREHASH_TargetPort; -extern char * _PREHASH_ObjectSpinStop; -extern char * _PREHASH_FullID; -extern char * _PREHASH_ActivateGroup; -extern char * _PREHASH_SysGPU; -extern char * _PREHASH_AvatarInterestsReply; -extern char * _PREHASH_StartLure; -extern char * _PREHASH_SysRAM; -extern char * _PREHASH_ObjectPosition; -extern char * _PREHASH_SitPosition; -extern char * _PREHASH_StartTime; -extern char * _PREHASH_BornOn; -extern char * _PREHASH_CameraCollidePlane; -extern char * _PREHASH_EconomyDataRequest; -extern char * _PREHASH_TeleportLureRequest; -extern char * _PREHASH_FolderID; -extern char * _PREHASH_RegionHandleRequest; -extern char * _PREHASH_ScriptDataRequest; -extern char * _PREHASH_GroupRoleDataRequest; -extern char * _PREHASH_GroupTitlesRequest; -extern char * _PREHASH_AgentWearablesRequest; -extern char * _PREHASH_MapBlockRequest; -extern char * _PREHASH_LureID; -extern char * _PREHASH_CopyCenters; -extern char * _PREHASH_ParamList; -extern char * _PREHASH_InventorySerial; -extern char * _PREHASH_EdgeDataPacket; -extern char * _PREHASH_AvatarPickerReply; -extern char * _PREHASH_ParcelDwellReply; -extern char * _PREHASH_IsForSale; -extern char * _PREHASH_MuteID; -extern char * _PREHASH_MeanCollisionAlert; -extern char * _PREHASH_CanAcceptTasks; -extern char * _PREHASH_ItemData; -extern char * _PREHASH_AnimationList; -extern char * _PREHASH_Reputation; -extern char * _PREHASH_IntValue; -extern char * _PREHASH_TargetType; -extern char * _PREHASH_Amount; -extern char * _PREHASH_HasAttachment; -extern char * _PREHASH_UpdateAttachment; -extern char * _PREHASH_RemoveAttachment; -extern char * _PREHASH_HeightWidthBlock; -extern char * _PREHASH_RequestObjectPropertiesFamily; -extern char * _PREHASH_ObjectPropertiesFamily; -extern char * _PREHASH_UserData; -extern char * _PREHASH_IsReadable; -extern char * _PREHASH_PathCurve; -extern char * _PREHASH_Status; -extern char * _PREHASH_FromGroup; -extern char * _PREHASH_AlreadyVoted; -extern char * _PREHASH_PlacesReply; -extern char * _PREHASH_DirPlacesReply; -extern char * _PREHASH_ParcelBuy; -extern char * _PREHASH_DirFindQueryBackend; -extern char * _PREHASH_DirPlacesQueryBackend; -extern char * _PREHASH_DirClassifiedQueryBackend; -extern char * _PREHASH_DirLandQueryBackend; -extern char * _PREHASH_DirPopularQueryBackend; -extern char * _PREHASH_HistoryData; -extern char * _PREHASH_SnapshotID; -extern char * _PREHASH_Aspect; -extern char * _PREHASH_ParamSize; -extern char * _PREHASH_VoteCast; -extern char * _PREHASH_CastsShadows; -extern char * _PREHASH_EveryoneMask; -extern char * _PREHASH_ObjectSpinUpdate; -extern char * _PREHASH_MaturePublish; -extern char * _PREHASH_UseExistingAsset; -extern char * _PREHASH_Powers; -extern char * _PREHASH_ParcelLocalID; -extern char * _PREHASH_TeleportCancel; -extern char * _PREHASH_UnixTime; -extern char * _PREHASH_QueryFlags; -extern char * _PREHASH_AlwaysRun; -extern char * _PREHASH_Bottom; -extern char * _PREHASH_ButtonData; -extern char * _PREHASH_SoundData; -extern char * _PREHASH_ViewerStats; -extern char * _PREHASH_RegionHandshake; -extern char * _PREHASH_ObjectDescription; -extern char * _PREHASH_Description; -extern char * _PREHASH_ParamType; -extern char * _PREHASH_UUIDNameReply; -extern char * _PREHASH_UUIDGroupNameReply; -extern char * _PREHASH_SaveAssetIntoInventory; -extern char * _PREHASH_UserInfo; -extern char * _PREHASH_AnimSequenceID; -extern char * _PREHASH_NVPairs; -extern char * _PREHASH_GroupNoticesListRequest; -extern char * _PREHASH_ParcelAccessListRequest; -extern char * _PREHASH_MuteListRequest; -extern char * _PREHASH_RpcChannelRequest; -extern char * _PREHASH_LandStatRequest; -extern char * _PREHASH_PlacesQuery; -extern char * _PREHASH_DirPlacesQuery; -extern char * _PREHASH_SortOrder; -extern char * _PREHASH_Hunter; -extern char * _PREHASH_SunAngVelocity; -extern char * _PREHASH_BinaryBucket; -extern char * _PREHASH_ImagePacket; -extern char * _PREHASH_StartGroupProposal; -extern char * _PREHASH_EnergyLevel; -extern char * _PREHASH_PriceForListing; -extern char * _PREHASH_Scale; -extern char * _PREHASH_EstateCovenantReply; -extern char * _PREHASH_ParentEstateID; -extern char * _PREHASH_Extra2; -extern char * _PREHASH_Throttle; -extern char * _PREHASH_SimIP; -extern char * _PREHASH_GodID; -extern char * _PREHASH_TeleportMinPrice; -extern char * _PREHASH_VoteItem; -extern char * _PREHASH_ObjectRotation; -extern char * _PREHASH_SitRotation; -extern char * _PREHASH_SnapSelection; -extern char * _PREHASH_SoundTrigger; -extern char * _PREHASH_TerrainRaiseLimit; -extern char * _PREHASH_Quorum; -extern char * _PREHASH_AgentBlock; -extern char * _PREHASH_CommandBlock; -extern char * _PREHASH_PricePublicObjectDecay; -extern char * _PREHASH_SpawnPointPos; -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_PreloadSound; -extern char * _PREHASH_ScreenshotID; -extern char * _PREHASH_CovenantTimestamp; -extern char * _PREHASH_OldestUnacked; -extern char * _PREHASH_SimulatorIP; -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_ParcelDivide; -extern char * _PREHASH_PriceObjectClaim; -extern char * _PREHASH_Field; -extern char * _PREHASH_Ratio; -extern char * _PREHASH_JoinGroupReply; -extern char * _PREHASH_LiveHelpGroupReply; -extern char * _PREHASH_Score; -extern char * _PREHASH_Image; -extern char * _PREHASH_ObjectClickAction; -extern char * _PREHASH_Parameter; -extern char * _PREHASH_Flags; -extern char * _PREHASH_Plane; -extern char * _PREHASH_Width; -extern char * _PREHASH_Right; -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_Modal; -extern char * _PREHASH_ChildAgentUnknown; -extern char * _PREHASH_LandingType; -extern char * _PREHASH_ScriptRunningReply; -extern char * _PREHASH_Reply; -extern char * _PREHASH_GroupAccountDetailsReply; -extern char * _PREHASH_TelehubRot; -extern char * _PREHASH_AcceptFriendship; -extern char * _PREHASH_ItemType; -extern char * _PREHASH_DwellInfo; -extern char * _PREHASH_AgentResume; -extern char * _PREHASH_MailFilter; -extern char * _PREHASH_Disconnect; -extern char * _PREHASH_SimPosition; -extern char * _PREHASH_SimWideTotalPrims; -extern char * _PREHASH_Index; -extern char * _PREHASH_SimFilename; -extern char * _PREHASH_LastOwnerID; -extern char * _PREHASH_GroupNoticeRequest; -extern char * _PREHASH_EmailMessageRequest; -extern char * _PREHASH_MapItemRequest; -extern char * _PREHASH_AgentCount; -extern char * _PREHASH_MessageBlock; -extern char * _PREHASH_FuseBlock; -extern char * _PREHASH_AgentGroupData; -extern char * _PREHASH_ClassifiedInfoUpdate; -extern char * _PREHASH_RegionPos; -extern char * _PREHASH_ParcelMediaUpdate; -extern char * _PREHASH_NoticeID; -extern char * _PREHASH_GridX; -extern char * _PREHASH_GridY; -extern char * _PREHASH_Title; -extern char * _PREHASH_AuctionID; -extern char * _PREHASH_VoteType; -extern char * _PREHASH_CategoryID; -extern char * _PREHASH_Token; -extern char * _PREHASH_AggregatePerms; -extern char * _PREHASH_ObjectSelect; -extern char * _PREHASH_ForceObjectSelect; -extern char * _PREHASH_Price; -extern char * _PREHASH_SunDirection; -extern char * _PREHASH_FromName; -extern char * _PREHASH_ChangeInventoryItemFlags; -extern char * _PREHASH_Force; -extern char * _PREHASH_TransactionBlock; -extern char * _PREHASH_PowersMask; -extern char * _PREHASH_Stamp; -extern char * _PREHASH_TotalCredits; -extern char * _PREHASH_State; -extern char * _PREHASH_TextureIndex; -extern char * _PREHASH_InviteeID; -extern char * _PREHASH_ParcelReclaim; -extern char * _PREHASH_Money; -extern char * _PREHASH_PathTwist; -extern char * _PREHASH_AuthBuyerID; -extern char * _PREHASH_Color; -extern char * _PREHASH_SourceType; -extern char * _PREHASH_World; -extern char * _PREHASH_QueryData; -extern char * _PREHASH_Users; -extern char * _PREHASH_SysOS; -extern char * _PREHASH_Notes; -extern char * _PREHASH_AvatarID; -extern char * _PREHASH_FounderID; -extern char * _PREHASH_EndPointID; -extern char * _PREHASH_LocationLookAt; -extern char * _PREHASH_Sound; -extern char * _PREHASH_Cover; -extern char * _PREHASH_TotalObjectCount; -extern char * _PREHASH_TextureEntry; -extern char * _PREHASH_SquareMetersCommitted; -extern char * _PREHASH_ChannelID; -extern char * _PREHASH_Dwell; -extern char * _PREHASH_North; -extern char * _PREHASH_AgentUpdate; -extern char * _PREHASH_PickGodDelete; -extern char * _PREHASH_HostName; -extern char * _PREHASH_PriceParcelClaim; -extern char * _PREHASH_ParcelClaim; -extern char * _PREHASH_AgentPowers; -extern char * _PREHASH_ProfileHollow; -extern char * _PREHASH_GroupRoleChanges; -extern char * _PREHASH_Count; -extern char * _PREHASH_South; -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; -extern char * _PREHASH_FolderData; -extern char * _PREHASH_AssetBlock; -extern char * _PREHASH_AcceptNotices; -extern char * _PREHASH_SetGroupAcceptNotices; -extern char * _PREHASH_CloseCircuit; -extern char * _PREHASH_TeleportFinish; -extern char * _PREHASH_PathRevolutions; -extern char * _PREHASH_ClassifiedInfoReply; -extern char * _PREHASH_ParcelInfoReply; -extern char * _PREHASH_AutosaveData; -extern char * _PREHASH_SetStartLocation; -extern char * _PREHASH_PassHours; -extern char * _PREHASH_AttachmentPt; -extern char * _PREHASH_ParcelFlags; -extern char * _PREHASH_NumVotes; -extern char * _PREHASH_AvatarPickerRequest; -extern char * _PREHASH_TeleportLocationRequest; -extern char * _PREHASH_DataHomeLocationRequest; -extern char * _PREHASH_EventNotificationAddRequest; -extern char * _PREHASH_ParcelDwellRequest; -extern char * _PREHASH_EventLocationRequest; -extern char * _PREHASH_SetStartLocationRequest; -extern char * _PREHASH_QueryStart; -extern char * _PREHASH_EjectData; -extern char * _PREHASH_AvatarTextureUpdate; -extern char * _PREHASH_RPCServerPort; -extern char * _PREHASH_Bytes; -extern char * _PREHASH_Extra; -extern char * _PREHASH_ForceScriptControlRelease; -extern char * _PREHASH_ParcelRelease; -extern char * _PREHASH_VFileType; -extern char * _PREHASH_EjectGroupMemberReply; -extern char * _PREHASH_ImageData; -extern char * _PREHASH_SimulatorViewerTimeMessage; -extern char * _PREHASH_Rotation; -extern char * _PREHASH_Selection; -extern char * _PREHASH_TransactionData; -extern char * _PREHASH_OperationData; -extern char * _PREHASH_ExpirationDate; -extern char * _PREHASH_ParcelDeedToGroup; -extern char * _PREHASH_AvatarPicksReply; -extern char * _PREHASH_GroupTitlesReply; -extern char * _PREHASH_AgentInfo; -extern char * _PREHASH_MoneyTransferBackend; -extern char * _PREHASH_NextOwnerMask; -extern char * _PREHASH_MuteData; -extern char * _PREHASH_PassPrice; -extern char * _PREHASH_SourceID; -extern char * _PREHASH_ChangeUserRights; -extern char * _PREHASH_TeleportFlags; -extern char * _PREHASH_SlaveParcelData; -extern char * _PREHASH_AssetData; -extern char * _PREHASH_MultipleObjectUpdate; -extern char * _PREHASH_ObjectUpdate; -extern char * _PREHASH_ImprovedTerseObjectUpdate; -extern char * _PREHASH_ConfirmXferPacket; -extern char * _PREHASH_StartPingCheck; -extern char * _PREHASH_SimWideDeletes; -extern char * _PREHASH_LandStatReply; -extern char * _PREHASH_IsPhantom; -extern char * _PREHASH_AgentList; -extern char * _PREHASH_SimApproved; -extern char * _PREHASH_RezObject; -extern char * _PREHASH_TaskLocalID; -extern char * _PREHASH_ClaimDate; -extern char * _PREHASH_MergeParcel; -extern char * _PREHASH_Priority; -extern char * _PREHASH_QueryText; -extern char * _PREHASH_GroupNoticeAdd; -extern char * _PREHASH_ReturnType; -extern char * _PREHASH_FetchFolders; -extern char * _PREHASH_SimulatorPublicHostBlock; -extern char * _PREHASH_HeaderData; -extern char * _PREHASH_RequestMultipleObjects; -extern char * _PREHASH_RetrieveInstantMessages; -extern char * _PREHASH_OpenCircuit; -extern char * _PREHASH_CrossedRegion; -extern char * _PREHASH_DirGroupsReply; -extern char * _PREHASH_AvatarGroupsReply; -extern char * _PREHASH_EmailMessageReply; -extern char * _PREHASH_GroupVoteHistoryItemReply; -extern char * _PREHASH_ViewerPosition; -extern char * _PREHASH_Position; -extern char * _PREHASH_ParentEstate; -extern char * _PREHASH_EstateName; -extern char * _PREHASH_MuteName; -extern char * _PREHASH_ParcelRename; -extern char * _PREHASH_ViewerFilename; -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_OpenEnrollment; -extern char * _PREHASH_GroupData; -extern char * _PREHASH_RequestGodlikePowers; -extern char * _PREHASH_GrantGodlikePowers; -extern char * _PREHASH_TransactionID; -extern char * _PREHASH_DestinationID; -extern char * _PREHASH_Controls; -extern char * _PREHASH_FirstDetachAll; -extern char * _PREHASH_EstateID; -extern char * _PREHASH_ImprovedInstantMessage; -extern char * _PREHASH_CheckParcelSales; -extern char * _PREHASH_ParcelSales; -extern char * _PREHASH_CurrentInterval; -extern char * _PREHASH_PriceRentLight; -extern char * _PREHASH_MediaAutoScale; -extern char * _PREHASH_NeighborBlock; -extern char * _PREHASH_LayerData; -extern char * _PREHASH_NVPairData; -extern char * _PREHASH_TeleportLocal; -extern char * _PREHASH_EjecteeID; -extern char * _PREHASH_VoteInitiator; -extern char * _PREHASH_TypeData; -extern char * _PREHASH_OwnerIDs; -extern char * _PREHASH_SystemKickUser; -extern char * _PREHASH_TransactionTime; -extern char * _PREHASH_TimeToLive; -extern char * _PREHASH_OldAgentID; -extern char * _PREHASH_MusicURL; -extern char * _PREHASH_ParcelPrimBonus; -extern char * _PREHASH_EjectUser; -extern char * _PREHASH_CoarseLocationUpdate; -extern char * _PREHASH_ChildAgentPositionUpdate; -extern char * _PREHASH_StoreLocal; -extern char * _PREHASH_GroupName; -extern char * _PREHASH_PriceParcelRent; -extern char * _PREHASH_SimStatus; -extern char * _PREHASH_TransactionSuccess; -extern char * _PREHASH_LureType; -extern char * _PREHASH_GroupMask; -extern char * _PREHASH_SitObject; -extern char * _PREHASH_Override; -extern char * _PREHASH_LocomotionState; -extern char * _PREHASH_PriceUpload; -extern char * _PREHASH_RemoveParcel; -extern char * _PREHASH_ConfirmAuctionStart; -extern char * _PREHASH_RpcScriptRequestInbound; -extern char * _PREHASH_ActiveGroupID; -extern char * _PREHASH_ParcelReturnObjects; -extern char * _PREHASH_TotalObjects; -extern char * _PREHASH_ObjectExtraParams; -extern char * _PREHASH_Questions; -extern char * _PREHASH_TransferAbort; -extern char * _PREHASH_TransferInventory; -extern char * _PREHASH_RayTargetID; -extern char * _PREHASH_ClaimPrice; -extern char * _PREHASH_ObjectProperties; -extern char * _PREHASH_ParcelProperties; -extern char * _PREHASH_EstateOwnerID; -extern char * _PREHASH_LogoutRequest; -extern char * _PREHASH_AssetUploadRequest; -extern char * _PREHASH_TransactionType; -extern char * _PREHASH_AvatarPropertiesUpdate; -extern char * _PREHASH_ParcelPropertiesUpdate; -extern char * _PREHASH_FetchItems; -extern char * _PREHASH_AbortXfer; -extern char * _PREHASH_DeRezAck; -extern char * _PREHASH_TakeControls; -extern char * _PREHASH_DirLandReply; -extern char * _PREHASH_MuteType; -extern char * _PREHASH_IMViaEMail; -extern char * _PREHASH_RentPrice; -extern char * _PREHASH_GenericMessage; -extern char * _PREHASH_ChildAgentAlive; -extern char * _PREHASH_AssetType; -extern char * _PREHASH_SpawnPointBlock; -extern char * _PREHASH_AttachmentBlock; -extern char * _PREHASH_ObjectMaterial; -extern char * _PREHASH_OwnerName; -extern char * _PREHASH_AvatarNotesReply; -extern char * _PREHASH_CacheID; -extern char * _PREHASH_OwnerMask; -extern char * _PREHASH_TransferInventoryAck; -extern char * _PREHASH_RegionDenyAgeUnverified; -extern char * _PREHASH_AgeVerificationBlock; -extern char * _PREHASH_UCoord; -extern char * _PREHASH_VCoord; -extern char * _PREHASH_FaceIndex; -extern char * _PREHASH_StatusData; -extern char * _PREHASH_ProductSKU; +extern char const* const _PREHASH_X; +extern char const* const _PREHASH_Y; +extern char const* const _PREHASH_Z; +extern char const* const _PREHASH_AddFlags; +extern char const* const _PREHASH_FailureInfo; +extern char const* const _PREHASH_MapData; +extern char const* const _PREHASH_AddItem; +extern char const* const _PREHASH_MeanCollision; +extern char const* const _PREHASH_RezScript; +extern char const* const _PREHASH_AvatarSitResponse; +extern char const* const _PREHASH_InventoryAssetResponse; +extern char const* const _PREHASH_KillObject; +extern char const* const _PREHASH_ProposalID; +extern char const* const _PREHASH_SerialNum; +extern char const* const _PREHASH_Duration; +extern char const* const _PREHASH_ScriptQuestion; +extern char const* const _PREHASH_AddCircuitCode; +extern char const* const _PREHASH_UseCircuitCode; +extern char const* const _PREHASH_ViewerCircuitCode; +extern char const* const _PREHASH_ScriptAnswerYes; +extern char const* const _PREHASH_PartnerID; +extern char const* const _PREHASH_DirLandQuery; +extern char const* const _PREHASH_TeleportStart; +extern char const* const _PREHASH_AboutText; +extern char const* const _PREHASH_VisualParam; +extern char const* const _PREHASH_GroupPrims; +extern char const* const _PREHASH_SelectedPrims; +extern char const* const _PREHASH_ID; +extern char const* const _PREHASH_UUIDNameRequest; +extern char const* const _PREHASH_UUIDGroupNameRequest; +extern char const* const _PREHASH_GroupAccountTransactionsRequest; +extern char const* const _PREHASH_MapNameRequest; +extern char const* const _PREHASH_UpdateSimulator; +extern char const* const _PREHASH_BillableFactor; +extern char const* const _PREHASH_ObjectBonusFactor; +extern char const* const _PREHASH_EnableSimulator; +extern char const* const _PREHASH_DisableSimulator; +extern char const* const _PREHASH_ConfirmEnableSimulator; +extern char const* const _PREHASH_LayerType; +extern char const* const _PREHASH_OwnerRole; +extern char const* const _PREHASH_ParcelOverlay; +extern char const* const _PREHASH_GroupOwned; +extern char const* const _PREHASH_IP; +extern char const* const _PREHASH_ChatFromViewer; +extern char const* const _PREHASH_AvgAgentsInView; +extern char const* const _PREHASH_AgentsInView; +extern char const* const _PREHASH_GroupTitle; +extern char const* const _PREHASH_MapLayerReply; +extern char const* const _PREHASH_CompoundMsgID; +extern char const* const _PREHASH_CameraConstraint; +extern char const* const _PREHASH_DownloadTotals; +extern char const* const _PREHASH_GenCounter; +extern char const* const _PREHASH_FrozenData; +extern char const* const _PREHASH_ChildAgentDying; +extern char const* const _PREHASH_To; +extern char const* const _PREHASH_CopyInventoryFromNotecard; +extern char const* const _PREHASH_RezObjectFromNotecard; +extern char const* const _PREHASH_ParcelDirFeeCurrent; +extern char const* const _PREHASH_SeedCapability; +extern char const* const _PREHASH_ObjectDuplicate; +extern char const* const _PREHASH_InventoryData; +extern char const* const _PREHASH_ReplyData; +extern char const* const _PREHASH_ResetList; +extern char const* const _PREHASH_MediaID; +extern char const* const _PREHASH_RelatedRights; +extern char const* const _PREHASH_RedirectGridX; +extern char const* const _PREHASH_RedirectGridY; +extern char const* const _PREHASH_TransferID; +extern char const* const _PREHASH_TexturesChanged; +extern char const* const _PREHASH_UserLookAt; +extern char const* const _PREHASH_TestBlock1; +extern char const* const _PREHASH_SensedData; +extern char const* const _PREHASH_UpdateBlock; +extern char const* const _PREHASH_ClassifiedGodDelete; +extern char const* const _PREHASH_ObjectGrabUpdate; +extern char const* const _PREHASH_LocationPos; +extern char const* const _PREHASH_TaxDate; +extern char const* const _PREHASH_StartDateTime; +extern char const* const _PREHASH_ObjectUpdateCached; +extern char const* const _PREHASH_Packets; +extern char const* const _PREHASH_FailureType; +extern char const* const _PREHASH_UpdateGroupInfo; +extern char const* const _PREHASH_ObjectPermissions; +extern char const* const _PREHASH_RevokePermissions; +extern char const* const _PREHASH_UpdateFlags; +extern char const* const _PREHASH_ObjectExportSelected; +extern char const* const _PREHASH_RezSelected; +extern char const* const _PREHASH_AutoPilot; +extern char const* const _PREHASH_UpdateMuteListEntry; +extern char const* const _PREHASH_RemoveMuteListEntry; +extern char const* const _PREHASH_SetSimStatusInDatabase; +extern char const* const _PREHASH_SetSimPresenceInDatabase; +extern char const* const _PREHASH_CameraProperty; +extern char const* const _PREHASH_BrushSize; +extern char const* const _PREHASH_SimulatorSetMap; +extern char const* const _PREHASH_RegionPresenceRequestByRegionID; +extern char const* const _PREHASH_ParcelObjectOwnersReply; +extern char const* const _PREHASH_GroupMembersReply; +extern char const* const _PREHASH_GroupRoleMembersReply; +extern char const* const _PREHASH_RequestRegionInfo; +extern char const* const _PREHASH_AABBMax; +extern char const* const _PREHASH_RequestPayPrice; +extern char const* const _PREHASH_SimulatorPresentAtLocation; +extern char const* const _PREHASH_AgentRequestSit; +extern char const* const _PREHASH_AABBMin; +extern char const* const _PREHASH_ClassifiedFlags; +extern char const* const _PREHASH_ControlFlags; +extern char const* const _PREHASH_TeleportRequest; +extern char const* const _PREHASH_ScriptTeleportRequest; +extern char const* const _PREHASH_EstateCovenantRequest; +extern char const* const _PREHASH_DateUTC; +extern char const* const _PREHASH_TaskIDs; +extern char const* const _PREHASH_RequestResult; +extern char const* const _PREHASH_CanAcceptAgents; +extern char const* const _PREHASH_ObjectSaleInfo; +extern char const* const _PREHASH_KillChildAgents; +extern char const* const _PREHASH_Balance; +extern char const* const _PREHASH_DerezContainer; +extern char const* const _PREHASH_ObjectData; +extern char const* const _PREHASH_CameraAtAxis; +extern char const* const _PREHASH_InfoBlock; +extern char const* const _PREHASH_OwnershipCost; +extern char const* const _PREHASH_AvatarNotesUpdate; +extern char const* const _PREHASH_PID; +extern char const* const _PREHASH_DirPopularReply; +extern char const* const _PREHASH_TerrainHeightRange00; +extern char const* const _PREHASH_SimData; +extern char const* const _PREHASH_TerrainHeightRange01; +extern char const* const _PREHASH_TerrainHeightRange10; +extern char const* const _PREHASH_TerrainHeightRange11; +extern char const* const _PREHASH_UpdateInventoryItem; +extern char const* const _PREHASH_UpdateCreateInventoryItem; +extern char const* const _PREHASH_MoveInventoryItem; +extern char const* const _PREHASH_CopyInventoryItem; +extern char const* const _PREHASH_LinkInventoryItem; +extern char const* const _PREHASH_RemoveInventoryItem; +extern char const* const _PREHASH_CreateInventoryItem; +extern char const* const _PREHASH_PathTwistBegin; +extern char const* const _PREHASH_CRC; +extern char const* const _PREHASH_AttachmentPoint; +extern char const* const _PREHASH_TelehubBlock; +extern char const* const _PREHASH_FOVBlock; +extern char const* const _PREHASH_StartLocationData; +extern char const* const _PREHASH_PositionData; +extern char const* const _PREHASH_TimeSinceLast; +extern char const* const _PREHASH_MapImage; +extern char const* const _PREHASH_Objects; +extern char const* const _PREHASH_URL; +extern char const* const _PREHASH_CreationDate; +extern char const* const _PREHASH_JointPivot; +extern char const* const _PREHASH_FPS; +extern char const* const _PREHASH_HasTelehub; +extern char const* const _PREHASH_PathEnd; +extern char const* const _PREHASH_ScriptDataReply; +extern char const* const _PREHASH_MapBlockReply; +extern char const* const _PREHASH_PropertiesData; +extern char const* const _PREHASH_ViewerEffect; +extern char const* const _PREHASH_FreezeUser; +extern char const* const _PREHASH_OwnerPrims; +extern char const* const _PREHASH_ObjectGrab; +extern char const* const _PREHASH_ToAgentID; +extern char const* const _PREHASH_SimulatorMapUpdate; +extern char const* const _PREHASH_TransferPacket; +extern char const* const _PREHASH_ObjectName; +extern char const* const _PREHASH_GroupPowers; +extern char const* const _PREHASH_OriginalName; +extern char const* const _PREHASH_CompletePingCheck; +extern char const* const _PREHASH_OnlineStatus; +extern char const* const _PREHASH_ObjectDrop; +extern char const* const _PREHASH_UseBigPackets; +extern char const* const _PREHASH_GroupNoticesListReply; +extern char const* const _PREHASH_ParcelAccessListReply; +extern char const* const _PREHASH_RpcChannelReply; +extern char const* const _PREHASH_RegionPresenceResponse; +extern char const* const _PREHASH_CharterMember; +extern char const* const _PREHASH_EdgeData; +extern char const* const _PREHASH_NameData; +extern char const* const _PREHASH_RegionPushOverride; +extern char const* const _PREHASH_SimName; +extern char const* const _PREHASH_UserReport; +extern char const* const _PREHASH_DownloadPriority; +extern char const* const _PREHASH_ToAgentId; +extern char const* const _PREHASH_DirPopularQuery; +extern char const* const _PREHASH_Mag; +extern char const* const _PREHASH_ParcelPropertiesRequestByID; +extern char const* const _PREHASH_ObjectLink; +extern char const* const _PREHASH_RpcScriptReplyInbound; +extern char const* const _PREHASH_RezData; +extern char const* const _PREHASH_RemoveInventoryObjects; +extern char const* const _PREHASH_GroupProposalBallot; +extern char const* const _PREHASH_RPCServerIP; +extern char const* const _PREHASH_Far; +extern char const* const _PREHASH_GodSessionID; +extern char const* const _PREHASH_FLAboutText; +extern char const* const _PREHASH_RegionHandshakeReply; +extern char const* const _PREHASH_GroupActiveProposalItemReply; +extern char const* const _PREHASH_MapItemReply; +extern char const* const _PREHASH_Seconds; +extern char const* const _PREHASH_UpdateUserInfo; +extern char const* const _PREHASH_AggregatePermTexturesOwner; +extern char const* const _PREHASH_Set; +extern char const* const _PREHASH_NewName; +extern char const* const _PREHASH_Key; +extern char const* const _PREHASH_AgentID; +extern char const* const _PREHASH_EventNotificationRemoveRequest; +extern char const* const _PREHASH_NewFolderID; +extern char const* const _PREHASH_Arc; +extern char const* const _PREHASH_RegionX; +extern char const* const _PREHASH_RegionY; +extern char const* const _PREHASH_RequestData; +extern char const* const _PREHASH_Msg; +extern char const* const _PREHASH_Top; +extern char const* const _PREHASH_MiscStats; +extern char const* const _PREHASH_ImageID; +extern char const* const _PREHASH_DataPacket; +extern char const* const _PREHASH_You; +extern char const* const _PREHASH_ScriptControlChange; +extern char const* const _PREHASH_LoadURL; +extern char const* const _PREHASH_SetCPURatio; +extern char const* const _PREHASH_NameValueData; +extern char const* const _PREHASH_AtomicPassObject; +extern char const* const _PREHASH_ErrorMessage; +extern char const* const _PREHASH_ViewerFrozenMessage; +extern char const* const _PREHASH_HealthMessage; +extern char const* const _PREHASH_LogTextMessage; +extern char const* const _PREHASH_TimeDilation; +extern char const* const _PREHASH_RemoveContribution; +extern char const* const _PREHASH_Contribution; +extern char const* const _PREHASH_SetGroupContribution; +extern char const* const _PREHASH_Offline; +extern char const* const _PREHASH_AgentIsNowWearing; +extern char const* const _PREHASH_Members; +extern char const* const _PREHASH_FailedResends; +extern char const* const _PREHASH_SecPerDay; +extern char const* const _PREHASH_CameraCenter; +extern char const* const _PREHASH_CameraLeftAxis; +extern char const* const _PREHASH_ExBlock; +extern char const* const _PREHASH_Channel; +extern char const* const _PREHASH_NetTest; +extern char const* const _PREHASH_DiscardLevel; +extern char const* const _PREHASH_LayerID; +extern char const* const _PREHASH_GrabOffset; +extern char const* const _PREHASH_SimPort; +extern char const* const _PREHASH_PricePerMeter; +extern char const* const _PREHASH_RegionFlags; +extern char const* const _PREHASH_VoteResult; +extern char const* const _PREHASH_ParcelDirFeeEstimate; +extern char const* const _PREHASH_ModifyBlock; +extern char const* const _PREHASH_InventoryBlock; +extern char const* const _PREHASH_ReplyBlock; +extern char const* const _PREHASH_ValidUntil; +extern char const* const _PREHASH_VelocityInterpolateOn; +extern char const* const _PREHASH_ClassifiedDelete; +extern char const* const _PREHASH_RegionDenyAnonymous; +extern char const* const _PREHASH_FLImageID; +extern char const* const _PREHASH_AllowPublish; +extern char const* const _PREHASH_SitName; +extern char const* const _PREHASH_RegionsVisited; +extern char const* const _PREHASH_DirClassifiedReply; +extern char const* const _PREHASH_AvatarClassifiedReply; +extern char const* const _PREHASH_MediaURL; +extern char const* const _PREHASH_CompleteAgentMovement; +extern char const* const _PREHASH_ClassifiedID; +extern char const* const _PREHASH_LocalID; +extern char const* const _PREHASH_SpaceIP; +extern char const* const _PREHASH_RemoveItem; +extern char const* const _PREHASH_LogFailedMoneyTransaction; +extern char const* const _PREHASH_ViewerStartAuction; +extern char const* const _PREHASH_StartAuction; +extern char const* const _PREHASH_DuplicateFlags; +extern char const* const _PREHASH_RegionInfo2; +extern char const* const _PREHASH_TextColor; +extern char const* const _PREHASH_SlaveID; +extern char const* const _PREHASH_Charter; +extern char const* const _PREHASH_AlertData; +extern char const* const _PREHASH_AlertInfo; +extern char const* const _PREHASH_TargetBlock; +extern char const* const _PREHASH_CheckParcelAuctions; +extern char const* const _PREHASH_ParcelAuctions; +extern char const* const _PREHASH_OwnerIsGroup; +extern char const* const _PREHASH_NameValuePair; +extern char const* const _PREHASH_RemoveNameValuePair; +extern char const* const _PREHASH_BulkUpdateInventory; +extern char const* const _PREHASH_UpdateTaskInventory; +extern char const* const _PREHASH_RemoveTaskInventory; +extern char const* const _PREHASH_MoveTaskInventory; +extern char const* const _PREHASH_RequestTaskInventory; +extern char const* const _PREHASH_ReplyTaskInventory; +extern char const* const _PREHASH_AggregatePermInventory; +extern char const* const _PREHASH_GroupAccountTransactionsReply; +extern char const* const _PREHASH_SimulatorInfo; +extern char const* const _PREHASH_WearableData; +extern char const* const _PREHASH_Enabled; +extern char const* const _PREHASH_Savings; +extern char const* const _PREHASH_SimulatorLoad; +extern char const* const _PREHASH_InternalRegionIP; +extern char const* const _PREHASH_ExternalRegionIP; +extern char const* const _PREHASH_TotalPairs; +extern char const* const _PREHASH_CreateGroupRequest; +extern char const* const _PREHASH_JoinGroupRequest; +extern char const* const _PREHASH_LeaveGroupRequest; +extern char const* const _PREHASH_InviteGroupRequest; +extern char const* const _PREHASH_LiveHelpGroupRequest; +extern char const* const _PREHASH_PriceParcelClaimFactor; +extern char const* const _PREHASH_BillableArea; +extern char const* const _PREHASH_ObjectID; +extern char const* const _PREHASH_ObjectFlagUpdate; +extern char const* const _PREHASH_GroupRoleUpdate; +extern char const* const _PREHASH_RequestInventoryAsset; +extern char const* const _PREHASH_ChangedGrid; +extern char const* const _PREHASH_AgentDropGroup; +extern char const* const _PREHASH_Details; +extern char const* const _PREHASH_LocationX; +extern char const* const _PREHASH_SaleType; +extern char const* const _PREHASH_LocationY; +extern char const* const _PREHASH_LocationZ; +extern char const* const _PREHASH_EconomyData; +extern char const* const _PREHASH_HeadRotation; +extern char const* const _PREHASH_DeleteOnCompletion; +extern char const* const _PREHASH_PublicPort; +extern char const* const _PREHASH_DirClassifiedQuery; +extern char const* const _PREHASH_CallbackID; +extern char const* const _PREHASH_RequestParcelTransfer; +extern char const* const _PREHASH_RoleCount; +extern char const* const _PREHASH_ObjectCapacity; +extern char const* const _PREHASH_RequestID; +extern char const* const _PREHASH_RequestXfer; +extern char const* const _PREHASH_ObjectTaxCurrent; +extern char const* const _PREHASH_LightTaxCurrent; +extern char const* const _PREHASH_LandTaxCurrent; +extern char const* const _PREHASH_GroupTaxCurrent; +extern char const* const _PREHASH_FetchInventoryDescendents; +extern char const* const _PREHASH_InventoryDescendents; +extern char const* const _PREHASH_Descendents; +extern char const* const _PREHASH_PurgeInventoryDescendents; +extern char const* const _PREHASH_ShowDir; +extern char const* const _PREHASH_IsOwner; +extern char const* const _PREHASH_Timestamp; +extern char const* const _PREHASH_GlobalPos; +extern char const* const _PREHASH_GrabOffsetInitial; +extern char const* const _PREHASH_IsTrial; +extern char const* const _PREHASH_ObjectDuplicateOnRay; +extern char const* const _PREHASH_GroupMembershipCount; +extern char const* const _PREHASH_MethodData; +extern char const* const _PREHASH_ActivateGestures; +extern char const* const _PREHASH_DeactivateGestures; +extern char const* const _PREHASH_ProposalData; +extern char const* const _PREHASH_PosGlobal; +extern char const* const _PREHASH_SearchID; +extern char const* const _PREHASH_RezMultipleAttachmentsFromInv; +extern char const* const _PREHASH_SearchName; +extern char const* const _PREHASH_VersionString; +extern char const* const _PREHASH_CreateGroupReply; +extern char const* const _PREHASH_LeaveGroupReply; +extern char const* const _PREHASH_ActualArea; +extern char const* const _PREHASH_Message; +extern char const* const _PREHASH_ClickAction; +extern char const* const _PREHASH_AssetUploadComplete; +extern char const* const _PREHASH_RequestType; +extern char const* const _PREHASH_UUID; +extern char const* const _PREHASH_BaseMask; +extern char const* const _PREHASH_NetBlock; +extern char const* const _PREHASH_GlobalX; +extern char const* const _PREHASH_GlobalY; +extern char const* const _PREHASH_CopyRotates; +extern char const* const _PREHASH_KickUserAck; +extern char const* const _PREHASH_TopPick; +extern char const* const _PREHASH_SessionID; +extern char const* const _PREHASH_GlobalZ; +extern char const* const _PREHASH_DeclineFriendship; +extern char const* const _PREHASH_FormFriendship; +extern char const* const _PREHASH_TerminateFriendship; +extern char const* const _PREHASH_TaskData; +extern char const* const _PREHASH_SimWideMaxPrims; +extern char const* const _PREHASH_TotalPrims; +extern char const* const _PREHASH_ProfileBegin; +extern char const* const _PREHASH_Request; +extern char const* const _PREHASH_GroupAccountDetailsRequest; +extern char const* const _PREHASH_GroupActiveProposalsRequest; +extern char const* const _PREHASH_StringValue; +extern char const* const _PREHASH_Version; +extern char const* const _PREHASH_OtherCount; +extern char const* const _PREHASH_MemberCount; +extern char const* const _PREHASH_ChatData; +extern char const* const _PREHASH_IsGroupOwned; +extern char const* const _PREHASH_EnergyEfficiency; +extern char const* const _PREHASH_PickInfoUpdate; +extern char const* const _PREHASH_PickDelete; +extern char const* const _PREHASH_ScriptReset; +extern char const* const _PREHASH_Requester; +extern char const* const _PREHASH_ForSale; +extern char const* const _PREHASH_NearestLandingRegionReply; +extern char const* const _PREHASH_ParcelID; +extern char const* const _PREHASH_Godlike; +extern char const* const _PREHASH_TotalDebits; +extern char const* const _PREHASH_Direction; +extern char const* const _PREHASH_HealthData; +extern char const* const _PREHASH_LeftAxis; +extern char const* const _PREHASH_LocationBlock; +extern char const* const _PREHASH_ObjectImage; +extern char const* const _PREHASH_TerrainStartHeight00; +extern char const* const _PREHASH_TerrainStartHeight01; +extern char const* const _PREHASH_TerrainStartHeight10; +extern char const* const _PREHASH_TerrainStartHeight11; +extern char const* const _PREHASH_WaterHeight; +extern char const* const _PREHASH_FetchInventoryReply; +extern char const* const _PREHASH_GroupAccountSummaryReply; +extern char const* const _PREHASH_AttachedSound; +extern char const* const _PREHASH_ParamInUse; +extern char const* const _PREHASH_GodKickUser; +extern char const* const _PREHASH_PickName; +extern char const* const _PREHASH_TaskName; +extern char const* const _PREHASH_ObjectCount; +extern char const* const _PREHASH_RegionPresenceRequestByHandle; +extern char const* const _PREHASH_RezSingleAttachmentFromInv; +extern char const* const _PREHASH_ChildAgentUpdate; +extern char const* const _PREHASH_IsOwnerGroup; +extern char const* const _PREHASH_AgentHeightWidth; +extern char const* const _PREHASH_VerticalAngle; +extern char const* const _PREHASH_WearableType; +extern char const* const _PREHASH_AggregatePermNextOwner; +extern char const* const _PREHASH_ShowInList; +extern char const* const _PREHASH_UpdateParcel; +extern char const* const _PREHASH_SetAlwaysRun; +extern char const* const _PREHASH_NVPair; +extern char const* const _PREHASH_SearchType; +extern char const* const _PREHASH_ObjectSpinStart; +extern char const* const _PREHASH_UseEstateSun; +extern char const* const _PREHASH_RegionID; +extern char const* const _PREHASH_AbuseRegionID; +extern char const* const _PREHASH_Creator; +extern char const* const _PREHASH_ProposalText; +extern char const* const _PREHASH_DirEventsReply; +extern char const* const _PREHASH_EventInfoReply; +extern char const* const _PREHASH_UserInfoReply; +extern char const* const _PREHASH_PathRadiusOffset; +extern char const* const _PREHASH_TextureData; +extern char const* const _PREHASH_ChatPass; +extern char const* const _PREHASH_TargetID; +extern char const* const _PREHASH_DefaultPayPrice; +extern char const* const _PREHASH_UserLocation; +extern char const* const _PREHASH_MaxPrims; +extern char const* const _PREHASH_LandmarkID; +extern char const* const _PREHASH_InitiateDownload; +extern char const* const _PREHASH_Name; +extern char const* const _PREHASH_OtherCleanTime; +extern char const* const _PREHASH_ParcelSetOtherCleanTime; +extern char const* const _PREHASH_TeleportPriceExponent; +extern char const* const _PREHASH_Gain; +extern char const* const _PREHASH_PacketAck; +extern char const* const _PREHASH_PathSkew; +extern char const* const _PREHASH_SimulatorShutdownRequest; +extern char const* const _PREHASH_NearestLandingRegionRequest; +extern char const* const _PREHASH_OtherID; +extern char const* const _PREHASH_MemberID; +extern char const* const _PREHASH_MapLayerRequest; +extern char const* const _PREHASH_ObjectScale; +extern char const* const _PREHASH_TargetIP; +extern char const* const _PREHASH_Redo; +extern char const* const _PREHASH_MoneyBalance; +extern char const* const _PREHASH_TrackAgent; +extern char const* const _PREHASH_MaxX; +extern char const* const _PREHASH_Data; +extern char const* const _PREHASH_MaxY; +extern char const* const _PREHASH_TextureAnim; +extern char const* const _PREHASH_ReturnIDs; +extern char const* const _PREHASH_Date; +extern char const* const _PREHASH_AgentWearablesUpdate; +extern char const* const _PREHASH_AgentDataUpdate; +extern char const* const _PREHASH_GroupDataUpdate; +extern char const* const _PREHASH_Hash; +extern char const* const _PREHASH_AgentGroupDataUpdate; +extern char const* const _PREHASH_Left; +extern char const* const _PREHASH_Mask; +extern char const* const _PREHASH_ForceMouselook; +extern char const* const _PREHASH_Success; +extern char const* const _PREHASH_ObjectGroup; +extern char const* const _PREHASH_SunHour; +extern char const* const _PREHASH_MinX; +extern char const* const _PREHASH_ScriptSensorReply; +extern char const* const _PREHASH_MinY; +extern char const* const _PREHASH_Command; +extern char const* const _PREHASH_Desc; +extern char const* const _PREHASH_AttachmentNeedsSave; +extern char const* const _PREHASH_HistoryItemData; +extern char const* const _PREHASH_AgentCachedTexture; +extern char const* const _PREHASH_Subject; +extern char const* const _PREHASH_East; +extern char const* const _PREHASH_QueryReplies; +extern char const* const _PREHASH_ObjectCategory; +extern char const* const _PREHASH_Time; +extern char const* const _PREHASH_CreateLandmarkForEvent; +extern char const* const _PREHASH_ParentID; +extern char const* const _PREHASH_Ping; +extern char const* const _PREHASH_Perp; +extern char const* const _PREHASH_Code; +extern char const* const _PREHASH_InvType; +extern char const* const _PREHASH_AgentFOV; +extern char const* const _PREHASH_Audible; +extern char const* const _PREHASH_AuctionData; +extern char const* const _PREHASH_IDBlock; +extern char const* const _PREHASH_West; +extern char const* const _PREHASH_Undo; +extern char const* const _PREHASH_TotalNumItems; +extern char const* const _PREHASH_Info; +extern char const* const _PREHASH_Area; +extern char const* const _PREHASH_SimCrashed; +extern char const* const _PREHASH_Text; +extern char const* const _PREHASH_PriceGroupCreate; +extern char const* const _PREHASH_ObjectShape; +extern char const* const _PREHASH_GroupRoleDataReply; +extern char const* const _PREHASH_MuteCRC; +extern char const* const _PREHASH_Size; +extern char const* const _PREHASH_FromAddress; +extern char const* const _PREHASH_Body; +extern char const* const _PREHASH_FileData; +extern char const* const _PREHASH_List; +extern char const* const _PREHASH_KickUser; +extern char const* const _PREHASH_OtherPrims; +extern char const* const _PREHASH_RunTime; +extern char const* const _PREHASH_GrantUserRights; +extern char const* const _PREHASH_RpcScriptRequestInboundForward; +extern char const* const _PREHASH_More; +extern char const* const _PREHASH_Majority; +extern char const* const _PREHASH_MetersTraveled; +extern char const* const _PREHASH_Stat; +extern char const* const _PREHASH_SoundID; +extern char const* const _PREHASH_Item; +extern char const* const _PREHASH_User; +extern char const* const _PREHASH_Prey; +extern char const* const _PREHASH_RayStart; +extern char const* const _PREHASH_UsecSinceStart; +extern char const* const _PREHASH_ParcelData; +extern char const* const _PREHASH_CameraUpAxis; +extern char const* const _PREHASH_ScriptDialog; +extern char const* const _PREHASH_MasterParcelData; +extern char const* const _PREHASH_Invalid; +extern char const* const _PREHASH_ProfileCurve; +extern char const* const _PREHASH_ParcelAccessListUpdate; +extern char const* const _PREHASH_MuteListUpdate; +extern char const* const _PREHASH_SendPacket; +extern char const* const _PREHASH_SendXferPacket; +extern char const* const _PREHASH_RegionDenyIdentified; +extern char const* const _PREHASH_NotecardItemID; +extern char const* const _PREHASH_LastName; +extern char const* const _PREHASH_From; +extern char const* const _PREHASH_RoleChange; +extern char const* const _PREHASH_Port; +extern char const* const _PREHASH_MemberTitle; +extern char const* const _PREHASH_LogParcelChanges; +extern char const* const _PREHASH_AgentCachedTextureResponse; +extern char const* const _PREHASH_DeRezObject; +extern char const* const _PREHASH_IsTemporary; +extern char const* const _PREHASH_InsigniaID; +extern char const* const _PREHASH_CheckFlags; +extern char const* const _PREHASH_EventID; +extern char const* const _PREHASH_Selected; +extern char const* const _PREHASH_FromAgentId; +extern char const* const _PREHASH_Type; +extern char const* const _PREHASH_ChatType; +extern char const* const _PREHASH_ReportData; +extern char const* const _PREHASH_RequestBlock; +extern char const* const _PREHASH_GrantData; +extern char const* const _PREHASH_DetachAttachmentIntoInv; +extern char const* const _PREHASH_ParcelDisableObjects; +extern char const* const _PREHASH_Sections; +extern char const* const _PREHASH_GodLevel; +extern char const* const _PREHASH_PayPriceReply; +extern char const* const _PREHASH_QueryID; +extern char const* const _PREHASH_CameraEyeOffset; +extern char const* const _PREHASH_AgentPosition; +extern char const* const _PREHASH_GrabPosition; +extern char const* const _PREHASH_OnlineNotification; +extern char const* const _PREHASH_OfflineNotification; +extern char const* const _PREHASH_SendPostcard; +extern char const* const _PREHASH_RequestFlags; +extern char const* const _PREHASH_GroupAccountSummaryRequest; +extern char const* const _PREHASH_GroupVoteHistoryRequest; +extern char const* const _PREHASH_ParamValue; +extern char const* const _PREHASH_MaxAgents; +extern char const* const _PREHASH_CreateNewOutfitAttachments; +extern char const* const _PREHASH_RegionHandle; +extern char const* const _PREHASH_TeleportProgress; +extern char const* const _PREHASH_AgentQuitCopy; +extern char const* const _PREHASH_AvatarInterestsUpdate; +extern char const* const _PREHASH_GroupNoticeID; +extern char const* const _PREHASH_ParcelName; +extern char const* const _PREHASH_PriceObjectRent; +extern char const* const _PREHASH_OfferCallingCard; +extern char const* const _PREHASH_AcceptCallingCard; +extern char const* const _PREHASH_DeclineCallingCard; +extern char const* const _PREHASH_AgentAccess; +extern char const* const _PREHASH_AgentLegacyAccess; +extern char const* const _PREHASH_AgentMaxAccess; +extern char const* const _PREHASH_DataHomeLocationReply; +extern char const* const _PREHASH_EventLocationReply; +extern char const* const _PREHASH_TerseDateID; +extern char const* const _PREHASH_ObjectOwner; +extern char const* const _PREHASH_AssetID; +extern char const* const _PREHASH_AlertMessage; +extern char const* const _PREHASH_AgentAlertMessage; +extern char const* const _PREHASH_EstateOwnerMessage; +extern char const* const _PREHASH_ParcelMediaCommandMessage; +extern char const* const _PREHASH_Auction; +extern char const* const _PREHASH_Category; +extern char const* const _PREHASH_FilePath; +extern char const* const _PREHASH_ItemFlags; +extern char const* const _PREHASH_Invoice; +extern char const* const _PREHASH_IntervalDays; +extern char const* const _PREHASH_PathScaleX; +extern char const* const _PREHASH_FromTaskID; +extern char const* const _PREHASH_PathScaleY; +extern char const* const _PREHASH_TimeInfo; +extern char const* const _PREHASH_PublicCount; +extern char const* const _PREHASH_ParcelJoin; +extern char const* const _PREHASH_GroupRolesCount; +extern char const* const _PREHASH_SimulatorBlock; +extern char const* const _PREHASH_GroupID; +extern char const* const _PREHASH_AgentVel; +extern char const* const _PREHASH_RequestImage; +extern char const* const _PREHASH_NetStats; +extern char const* const _PREHASH_AgentPos; +extern char const* const _PREHASH_AgentSit; +extern char const* const _PREHASH_Material; +extern char const* const _PREHASH_ObjectDeGrab; +extern char const* const _PREHASH_VelocityInterpolateOff; +extern char const* const _PREHASH_AuthorizedBuyerID; +extern char const* const _PREHASH_AvatarPropertiesReply; +extern char const* const _PREHASH_GroupProfileReply; +extern char const* const _PREHASH_SimOwner; +extern char const* const _PREHASH_SalePrice; +extern char const* const _PREHASH_Animation; +extern char const* const _PREHASH_OwnerID; +extern char const* const _PREHASH_NearestLandingRegionUpdated; +extern char const* const _PREHASH_PassToAgent; +extern char const* const _PREHASH_PreyAgent; +extern char const* const _PREHASH_SimStats; +extern char const* const _PREHASH_LogoutReply; +extern char const* const _PREHASH_FeatureDisabled; +extern char const* const _PREHASH_PhysicalAvatarEventList; +extern char const* const _PREHASH_ObjectLocalID; +extern char const* const _PREHASH_Dropped; +extern char const* const _PREHASH_WebProfilesDisabled; +extern char const* const _PREHASH_Destination; +extern char const* const _PREHASH_MasterID; +extern char const* const _PREHASH_TransferData; +extern char const* const _PREHASH_WantToMask; +extern char const* const _PREHASH_ParcelSelectObjects; +extern char const* const _PREHASH_ExtraParams; +extern char const* const _PREHASH_CreatorID; +extern char const* const _PREHASH_Summary; +extern char const* const _PREHASH_BuyObjectInventory; +extern char const* const _PREHASH_FetchInventory; +extern char const* const _PREHASH_InventoryID; +extern char const* const _PREHASH_PacketNumber; +extern char const* const _PREHASH_SetFollowCamProperties; +extern char const* const _PREHASH_ClearFollowCamProperties; +extern char const* const _PREHASH_SequenceID; +extern char const* const _PREHASH_DataServerLogout; +extern char const* const _PREHASH_NameValue; +extern char const* const _PREHASH_PathShearX; +extern char const* const _PREHASH_PathShearY; +extern char const* const _PREHASH_Velocity; +extern char const* const _PREHASH_SecPerYear; +extern char const* const _PREHASH_FirstName; +extern char const* const _PREHASH_AttachedSoundGainChange; +extern char const* const _PREHASH_LocationID; +extern char const* const _PREHASH_Running; +extern char const* const _PREHASH_AgentThrottle; +extern char const* const _PREHASH_NeighborList; +extern char const* const _PREHASH_PathTaperX; +extern char const* const _PREHASH_PathTaperY; +extern char const* const _PREHASH_AgentRelated; +extern char const* const _PREHASH_GranterBlock; +extern char const* const _PREHASH_UseCachedMuteList; +extern char const* const _PREHASH_FailStats; +extern char const* const _PREHASH_Tempfile; +extern char const* const _PREHASH_BuyerID; +extern char const* const _PREHASH_DirPeopleReply; +extern char const* const _PREHASH_TransferInfo; +extern char const* const _PREHASH_AvatarPickerRequestBackend; +extern char const* const _PREHASH_AvatarPropertiesRequestBackend; +extern char const* const _PREHASH_UpdateData; +extern char const* const _PREHASH_SimFPS; +extern char const* const _PREHASH_ReporterID; +extern char const* const _PREHASH_ButtonLabel; +extern char const* const _PREHASH_GranterID; +extern char const* const _PREHASH_WantToText; +extern char const* const _PREHASH_ReportType; +extern char const* const _PREHASH_SimulatorReady; +extern char const* const _PREHASH_DataBlock; +extern char const* const _PREHASH_AnimationSourceList; +extern char const* const _PREHASH_SubscribeLoad; +extern char const* const _PREHASH_UnsubscribeLoad; +extern char const* const _PREHASH_Packet; +extern char const* const _PREHASH_UndoLand; +extern char const* const _PREHASH_SimAccess; +extern char const* const _PREHASH_AbuserID; +extern char const* const _PREHASH_MembershipFee; +extern char const* const _PREHASH_InviteGroupResponse; +extern char const* const _PREHASH_CreateInventoryFolder; +extern char const* const _PREHASH_UpdateInventoryFolder; +extern char const* const _PREHASH_MoveInventoryFolder; +extern char const* const _PREHASH_RemoveInventoryFolder; +extern char const* const _PREHASH_MoneyData; +extern char const* const _PREHASH_ObjectDeselect; +extern char const* const _PREHASH_NewAssetID; +extern char const* const _PREHASH_ObjectAdd; +extern char const* const _PREHASH_SimulatorFeatures; +extern char const* const _PREHASH_RayEndIsIntersection; +extern char const* const _PREHASH_CompleteAuction; +extern char const* const _PREHASH_CircuitCode; +extern char const* const _PREHASH_AgentMovementComplete; +extern char const* const _PREHASH_ViewerIP; +extern char const* const _PREHASH_Header; +extern char const* const _PREHASH_GestureFlags; +extern char const* const _PREHASH_XferID; +extern char const* const _PREHASH_StatValue; +extern char const* const _PREHASH_TaskID; +extern char const* const _PREHASH_PickID; +extern char const* const _PREHASH_RayEnd; +extern char const* const _PREHASH_Throttles; +extern char const* const _PREHASH_RebakeAvatarTextures; +extern char const* const _PREHASH_UpAxis; +extern char const* const _PREHASH_AgentTextures; +extern char const* const _PREHASH_NotecardData; +extern char const* const _PREHASH_Radius; +extern char const* const _PREHASH_OffCircuit; +extern char const* const _PREHASH_Access; +extern char const* const _PREHASH_TitleRoleID; +extern char const* const _PREHASH_SquareMetersCredit; +extern char const* const _PREHASH_Filename; +extern char const* const _PREHASH_ClassifiedInfoRequest; +extern char const* const _PREHASH_ParcelInfoRequest; +extern char const* const _PREHASH_ParcelObjectOwnersRequest; +extern char const* const _PREHASH_TeleportLandmarkRequest; +extern char const* const _PREHASH_EventInfoRequest; +extern char const* const _PREHASH_MoneyBalanceRequest; +extern char const* const _PREHASH_GroupMembersRequest; +extern char const* const _PREHASH_GroupRoleMembersRequest; +extern char const* const _PREHASH_ChatFromSimulator; +extern char const* const _PREHASH_OldFolderID; +extern char const* const _PREHASH_UserInfoRequest; +extern char const* const _PREHASH_TextureID; +extern char const* const _PREHASH_ProfileURL; +extern char const* const _PREHASH_Handle; +extern char const* const _PREHASH_ButtonIndex; +extern char const* const _PREHASH_GetScriptRunning; +extern char const* const _PREHASH_SetScriptRunning; +extern char const* const _PREHASH_Health; +extern char const* const _PREHASH_CircuitInfo; +extern char const* const _PREHASH_ObjectBuy; +extern char const* const _PREHASH_ProfileEnd; +extern char const* const _PREHASH_Effect; +extern char const* const _PREHASH_TestMessage; +extern char const* const _PREHASH_ScriptMailRegistration; +extern char const* const _PREHASH_AgentSetAppearance; +extern char const* const _PREHASH_AvatarAppearance; +extern char const* const _PREHASH_RegionData; +extern char const* const _PREHASH_RequestingRegionData; +extern char const* const _PREHASH_LandingRegionData; +extern char const* const _PREHASH_SitTransform; +extern char const* const _PREHASH_TerrainBase0; +extern char const* const _PREHASH_SkillsMask; +extern char const* const _PREHASH_AtAxis; +extern char const* const _PREHASH_TerrainBase1; +extern char const* const _PREHASH_Reason; +extern char const* const _PREHASH_TerrainBase2; +extern char const* const _PREHASH_TerrainBase3; +extern char const* const _PREHASH_Params; +extern char const* const _PREHASH_PingID; +extern char const* const _PREHASH_Change; +extern char const* const _PREHASH_Height; +extern char const* const _PREHASH_Region; +extern char const* const _PREHASH_TelehubInfo; +extern char const* const _PREHASH_StateSave; +extern char const* const _PREHASH_RoleData; +extern char const* const _PREHASH_AgentAnimation; +extern char const* const _PREHASH_AvatarAnimation; +extern char const* const _PREHASH_LogDwellTime; +extern char const* const _PREHASH_ParcelGodMarkAsContent; +extern char const* const _PREHASH_UsePhysics; +extern char const* const _PREHASH_RegionDenyTransacted; +extern char const* const _PREHASH_JointType; +extern char const* const _PREHASH_ObjectTaxEstimate; +extern char const* const _PREHASH_LightTaxEstimate; +extern char const* const _PREHASH_LandTaxEstimate; +extern char const* const _PREHASH_TeleportLandingStatusChanged; +extern char const* const _PREHASH_GroupTaxEstimate; +extern char const* const _PREHASH_AvgViewerFPS; +extern char const* const _PREHASH_Buttons; +extern char const* const _PREHASH_Sender; +extern char const* const _PREHASH_Dialog; +extern char const* const _PREHASH_TargetData; +extern char const* const _PREHASH_DestID; +extern char const* const _PREHASH_PricePublicObjectDelete; +extern char const* const _PREHASH_ObjectDelete; +extern char const* const _PREHASH_Delete; +extern char const* const _PREHASH_EventGodDelete; +extern char const* const _PREHASH_LastTaxDate; +extern char const* const _PREHASH_MapImageID; +extern char const* const _PREHASH_EndDateTime; +extern char const* const _PREHASH_TerrainDetail0; +extern char const* const _PREHASH_TerrainDetail1; +extern char const* const _PREHASH_TerrainDetail2; +extern char const* const _PREHASH_TerrainDetail3; +extern char const* const _PREHASH_Offset; +extern char const* const _PREHASH_ObjectDelink; +extern char const* const _PREHASH_TargetObject; +extern char const* const _PREHASH_IsEstateManager; +extern char const* const _PREHASH_CancelAuction; +extern char const* const _PREHASH_ObjectDetach; +extern char const* const _PREHASH_Compressed; +extern char const* const _PREHASH_PathBegin; +extern char const* const _PREHASH_BypassRaycast; +extern char const* const _PREHASH_WinnerID; +extern char const* const _PREHASH_ChannelType; +extern char const* const _PREHASH_NonExemptMembers; +extern char const* const _PREHASH_Agents; +extern char const* const _PREHASH_MemberData; +extern char const* const _PREHASH_ToGroupID; +extern char const* const _PREHASH_ImageNotInDatabase; +extern char const* const _PREHASH_StartDate; +extern char const* const _PREHASH_AnimID; +extern char const* const _PREHASH_Serial; +extern char const* const _PREHASH_AbuseRegionName; +extern char const* const _PREHASH_ModifyLand; +extern char const* const _PREHASH_Digest; +extern char const* const _PREHASH_Victim; +extern char const* const _PREHASH_Script; +extern char const* const _PREHASH_PickInfoReply; +extern char const* const _PREHASH_MoneyBalanceReply; +extern char const* const _PREHASH_RoutedMoneyBalanceReply; +extern char const* const _PREHASH_RoleID; +extern char const* const _PREHASH_RegionInfo; +extern char const* const _PREHASH_GodUpdateRegionInfo; +extern char const* const _PREHASH_StartAnim; +extern char const* const _PREHASH_Action; +extern char const* const _PREHASH_Location; +extern char const* const _PREHASH_Rights; +extern char const* const _PREHASH_SearchDir; +extern char const* const _PREHASH_TransferRequest; +extern char const* const _PREHASH_ScriptSensorRequest; +extern char const* const _PREHASH_MoneyTransferRequest; +extern char const* const _PREHASH_EjectGroupMemberRequest; +extern char const* const _PREHASH_SkillsText; +extern char const* const _PREHASH_Resent; +extern char const* const _PREHASH_Center; +extern char const* const _PREHASH_SharedData; +extern char const* const _PREHASH_PSBlock; +extern char const* const _PREHASH_UUIDNameBlock; +extern char const* const _PREHASH_GroupTitleUpdate; +extern char const* const _PREHASH_Method; +extern char const* const _PREHASH_TouchName; +extern char const* const _PREHASH_UpdateType; +extern char const* const _PREHASH_KickedFromEstateID; +extern char const* const _PREHASH_CandidateID; +extern char const* const _PREHASH_ParamData; +extern char const* const _PREHASH_GodlikeMessage; +extern char const* const _PREHASH_SystemMessage; +extern char const* const _PREHASH_BodyRotation; +extern char const* const _PREHASH_SearchRegions; +extern char const* const _PREHASH_AnimationData; +extern char const* const _PREHASH_StatID; +extern char const* const _PREHASH_ItemID; +extern char const* const _PREHASH_ScriptDialogReply; +extern char const* const _PREHASH_RegionIDAndHandleReply; +extern char const* const _PREHASH_CameraAtOffset; +extern char const* const _PREHASH_VoteID; +extern char const* const _PREHASH_ParcelGodForceOwner; +extern char const* const _PREHASH_Filter; +extern char const* const _PREHASH_InviteData; +extern char const* const _PREHASH_PCode; +extern char const* const _PREHASH_SearchPos; +extern char const* const _PREHASH_PreyID; +extern char const* const _PREHASH_TerrainLowerLimit; +extern char const* const _PREHASH_EventFlags; +extern char const* const _PREHASH_TallyVotes; +extern char const* const _PREHASH_Result; +extern char const* const _PREHASH_LookAt; +extern char const* const _PREHASH_SearchOrder; +extern char const* const _PREHASH_PayButton; +extern char const* const _PREHASH_SelfCount; +extern char const* const _PREHASH_PacketCount; +extern char const* const _PREHASH_ParcelBuyPass; +extern char const* const _PREHASH_OldItemID; +extern char const* const _PREHASH_RegionPort; +extern char const* const _PREHASH_PriceEnergyUnit; +extern char const* const _PREHASH_Bitmap; +extern char const* const _PREHASH_CacheMissType; +extern char const* const _PREHASH_VFileID; +extern char const* const _PREHASH_GroupInsigniaID; +extern char const* const _PREHASH_Online; +extern char const* const _PREHASH_KickFlags; +extern char const* const _PREHASH_CovenantID; +extern char const* const _PREHASH_SysCPU; +extern char const* const _PREHASH_EMail; +extern char const* const _PREHASH_AggregatePermTextures; +extern char const* const _PREHASH_ChatChannel; +extern char const* const _PREHASH_ReturnID; +extern char const* const _PREHASH_ObjectAttach; +extern char const* const _PREHASH_TargetPort; +extern char const* const _PREHASH_ObjectSpinStop; +extern char const* const _PREHASH_FullID; +extern char const* const _PREHASH_ActivateGroup; +extern char const* const _PREHASH_SysGPU; +extern char const* const _PREHASH_AvatarInterestsReply; +extern char const* const _PREHASH_StartLure; +extern char const* const _PREHASH_SysRAM; +extern char const* const _PREHASH_ObjectPosition; +extern char const* const _PREHASH_SitPosition; +extern char const* const _PREHASH_StartTime; +extern char const* const _PREHASH_BornOn; +extern char const* const _PREHASH_CameraCollidePlane; +extern char const* const _PREHASH_EconomyDataRequest; +extern char const* const _PREHASH_TeleportLureRequest; +extern char const* const _PREHASH_FolderID; +extern char const* const _PREHASH_RegionHandleRequest; +extern char const* const _PREHASH_ScriptDataRequest; +extern char const* const _PREHASH_GroupRoleDataRequest; +extern char const* const _PREHASH_GroupTitlesRequest; +extern char const* const _PREHASH_AgentWearablesRequest; +extern char const* const _PREHASH_MapBlockRequest; +extern char const* const _PREHASH_LureID; +extern char const* const _PREHASH_CopyCenters; +extern char const* const _PREHASH_ParamList; +extern char const* const _PREHASH_InventorySerial; +extern char const* const _PREHASH_EdgeDataPacket; +extern char const* const _PREHASH_AvatarPickerReply; +extern char const* const _PREHASH_ParcelDwellReply; +extern char const* const _PREHASH_IsForSale; +extern char const* const _PREHASH_MuteID; +extern char const* const _PREHASH_MeanCollisionAlert; +extern char const* const _PREHASH_CanAcceptTasks; +extern char const* const _PREHASH_ItemData; +extern char const* const _PREHASH_AnimationList; +extern char const* const _PREHASH_Reputation; +extern char const* const _PREHASH_IntValue; +extern char const* const _PREHASH_TargetType; +extern char const* const _PREHASH_Amount; +extern char const* const _PREHASH_HasAttachment; +extern char const* const _PREHASH_UpdateAttachment; +extern char const* const _PREHASH_RemoveAttachment; +extern char const* const _PREHASH_HeightWidthBlock; +extern char const* const _PREHASH_RequestObjectPropertiesFamily; +extern char const* const _PREHASH_ObjectPropertiesFamily; +extern char const* const _PREHASH_UserData; +extern char const* const _PREHASH_IsReadable; +extern char const* const _PREHASH_PathCurve; +extern char const* const _PREHASH_Status; +extern char const* const _PREHASH_FromGroup; +extern char const* const _PREHASH_AlreadyVoted; +extern char const* const _PREHASH_PlacesReply; +extern char const* const _PREHASH_DirPlacesReply; +extern char const* const _PREHASH_ParcelBuy; +extern char const* const _PREHASH_DirFindQueryBackend; +extern char const* const _PREHASH_DirPlacesQueryBackend; +extern char const* const _PREHASH_DirClassifiedQueryBackend; +extern char const* const _PREHASH_DirLandQueryBackend; +extern char const* const _PREHASH_DirPopularQueryBackend; +extern char const* const _PREHASH_HistoryData; +extern char const* const _PREHASH_SnapshotID; +extern char const* const _PREHASH_Aspect; +extern char const* const _PREHASH_ParamSize; +extern char const* const _PREHASH_VoteCast; +extern char const* const _PREHASH_CastsShadows; +extern char const* const _PREHASH_EveryoneMask; +extern char const* const _PREHASH_ObjectSpinUpdate; +extern char const* const _PREHASH_MaturePublish; +extern char const* const _PREHASH_UseExistingAsset; +extern char const* const _PREHASH_Powers; +extern char const* const _PREHASH_ParcelLocalID; +extern char const* const _PREHASH_TeleportCancel; +extern char const* const _PREHASH_UnixTime; +extern char const* const _PREHASH_QueryFlags; +extern char const* const _PREHASH_AlwaysRun; +extern char const* const _PREHASH_Bottom; +extern char const* const _PREHASH_ButtonData; +extern char const* const _PREHASH_SoundData; +extern char const* const _PREHASH_ViewerStats; +extern char const* const _PREHASH_RegionHandshake; +extern char const* const _PREHASH_ObjectDescription; +extern char const* const _PREHASH_Description; +extern char const* const _PREHASH_ParamType; +extern char const* const _PREHASH_UUIDNameReply; +extern char const* const _PREHASH_UUIDGroupNameReply; +extern char const* const _PREHASH_SaveAssetIntoInventory; +extern char const* const _PREHASH_UserInfo; +extern char const* const _PREHASH_AnimSequenceID; +extern char const* const _PREHASH_NVPairs; +extern char const* const _PREHASH_GroupNoticesListRequest; +extern char const* const _PREHASH_ParcelAccessListRequest; +extern char const* const _PREHASH_MuteListRequest; +extern char const* const _PREHASH_RpcChannelRequest; +extern char const* const _PREHASH_LandStatRequest; +extern char const* const _PREHASH_PlacesQuery; +extern char const* const _PREHASH_DirPlacesQuery; +extern char const* const _PREHASH_SortOrder; +extern char const* const _PREHASH_Hunter; +extern char const* const _PREHASH_SunAngVelocity; +extern char const* const _PREHASH_BinaryBucket; +extern char const* const _PREHASH_ImagePacket; +extern char const* const _PREHASH_StartGroupProposal; +extern char const* const _PREHASH_EnergyLevel; +extern char const* const _PREHASH_PriceForListing; +extern char const* const _PREHASH_Scale; +extern char const* const _PREHASH_EstateCovenantReply; +extern char const* const _PREHASH_ParentEstateID; +extern char const* const _PREHASH_Extra2; +extern char const* const _PREHASH_Throttle; +extern char const* const _PREHASH_SimIP; +extern char const* const _PREHASH_GodID; +extern char const* const _PREHASH_TeleportMinPrice; +extern char const* const _PREHASH_VoteItem; +extern char const* const _PREHASH_ObjectRotation; +extern char const* const _PREHASH_SitRotation; +extern char const* const _PREHASH_SnapSelection; +extern char const* const _PREHASH_SoundTrigger; +extern char const* const _PREHASH_TerrainRaiseLimit; +extern char const* const _PREHASH_Quorum; +extern char const* const _PREHASH_AgentBlock; +extern char const* const _PREHASH_CommandBlock; +extern char const* const _PREHASH_PricePublicObjectDecay; +extern char const* const _PREHASH_SpawnPointPos; +extern char const* const _PREHASH_VolumeDetail; +extern char const* const _PREHASH_FromAgentName; +extern char const* const _PREHASH_Range; +extern char const* const _PREHASH_DirectoryVisibility; +extern char const* const _PREHASH_PublicIP; +extern char const* const _PREHASH_TeleportFailed; +extern char const* const _PREHASH_PreloadSound; +extern char const* const _PREHASH_ScreenshotID; +extern char const* const _PREHASH_CovenantTimestamp; +extern char const* const _PREHASH_OldestUnacked; +extern char const* const _PREHASH_SimulatorIP; +extern char const* const _PREHASH_Value; +extern char const* const _PREHASH_JointAxisOrAnchor; +extern char const* const _PREHASH_Test0; +extern char const* const _PREHASH_Test1; +extern char const* const _PREHASH_Test2; +extern char const* const _PREHASH_SunPhase; +extern char const* const _PREHASH_ParcelDivide; +extern char const* const _PREHASH_PriceObjectClaim; +extern char const* const _PREHASH_Field; +extern char const* const _PREHASH_Ratio; +extern char const* const _PREHASH_JoinGroupReply; +extern char const* const _PREHASH_LiveHelpGroupReply; +extern char const* const _PREHASH_Score; +extern char const* const _PREHASH_Image; +extern char const* const _PREHASH_ObjectClickAction; +extern char const* const _PREHASH_Parameter; +extern char const* const _PREHASH_Flags; +extern char const* const _PREHASH_Plane; +extern char const* const _PREHASH_Width; +extern char const* const _PREHASH_Right; +extern char const* const _PREHASH_DirFindQuery; +extern char const* const _PREHASH_Textures; +extern char const* const _PREHASH_EventData; +extern char const* const _PREHASH_Final; +extern char const* const _PREHASH_System; +extern char const* const _PREHASH_TelehubPos; +extern char const* const _PREHASH_ReportAutosaveCrash; +extern char const* const _PREHASH_CreateTrustedCircuit; +extern char const* const _PREHASH_DenyTrustedCircuit; +extern char const* const _PREHASH_RequestTrustedCircuit; +extern char const* const _PREHASH_Codec; +extern char const* const _PREHASH_Modal; +extern char const* const _PREHASH_ChildAgentUnknown; +extern char const* const _PREHASH_LandingType; +extern char const* const _PREHASH_ScriptRunningReply; +extern char const* const _PREHASH_Reply; +extern char const* const _PREHASH_GroupAccountDetailsReply; +extern char const* const _PREHASH_TelehubRot; +extern char const* const _PREHASH_AcceptFriendship; +extern char const* const _PREHASH_ItemType; +extern char const* const _PREHASH_DwellInfo; +extern char const* const _PREHASH_AgentResume; +extern char const* const _PREHASH_MailFilter; +extern char const* const _PREHASH_Disconnect; +extern char const* const _PREHASH_SimPosition; +extern char const* const _PREHASH_SimWideTotalPrims; +extern char const* const _PREHASH_Index; +extern char const* const _PREHASH_SimFilename; +extern char const* const _PREHASH_LastOwnerID; +extern char const* const _PREHASH_GroupNoticeRequest; +extern char const* const _PREHASH_EmailMessageRequest; +extern char const* const _PREHASH_MapItemRequest; +extern char const* const _PREHASH_AgentCount; +extern char const* const _PREHASH_MessageBlock; +extern char const* const _PREHASH_FuseBlock; +extern char const* const _PREHASH_AgentGroupData; +extern char const* const _PREHASH_ClassifiedInfoUpdate; +extern char const* const _PREHASH_RegionPos; +extern char const* const _PREHASH_ParcelMediaUpdate; +extern char const* const _PREHASH_NoticeID; +extern char const* const _PREHASH_GridX; +extern char const* const _PREHASH_GridY; +extern char const* const _PREHASH_Title; +extern char const* const _PREHASH_AuctionID; +extern char const* const _PREHASH_VoteType; +extern char const* const _PREHASH_CategoryID; +extern char const* const _PREHASH_Token; +extern char const* const _PREHASH_AggregatePerms; +extern char const* const _PREHASH_ObjectSelect; +extern char const* const _PREHASH_ForceObjectSelect; +extern char const* const _PREHASH_Price; +extern char const* const _PREHASH_SunDirection; +extern char const* const _PREHASH_FromName; +extern char const* const _PREHASH_ChangeInventoryItemFlags; +extern char const* const _PREHASH_Force; +extern char const* const _PREHASH_TransactionBlock; +extern char const* const _PREHASH_PowersMask; +extern char const* const _PREHASH_Stamp; +extern char const* const _PREHASH_TotalCredits; +extern char const* const _PREHASH_State; +extern char const* const _PREHASH_TextureIndex; +extern char const* const _PREHASH_InviteeID; +extern char const* const _PREHASH_ParcelReclaim; +extern char const* const _PREHASH_Money; +extern char const* const _PREHASH_PathTwist; +extern char const* const _PREHASH_AuthBuyerID; +extern char const* const _PREHASH_Color; +extern char const* const _PREHASH_SourceType; +extern char const* const _PREHASH_World; +extern char const* const _PREHASH_QueryData; +extern char const* const _PREHASH_Users; +extern char const* const _PREHASH_SysOS; +extern char const* const _PREHASH_Notes; +extern char const* const _PREHASH_AvatarID; +extern char const* const _PREHASH_FounderID; +extern char const* const _PREHASH_EndPointID; +extern char const* const _PREHASH_LocationLookAt; +extern char const* const _PREHASH_Sound; +extern char const* const _PREHASH_Cover; +extern char const* const _PREHASH_TotalObjectCount; +extern char const* const _PREHASH_TextureEntry; +extern char const* const _PREHASH_SquareMetersCommitted; +extern char const* const _PREHASH_ChannelID; +extern char const* const _PREHASH_Dwell; +extern char const* const _PREHASH_North; +extern char const* const _PREHASH_AgentUpdate; +extern char const* const _PREHASH_PickGodDelete; +extern char const* const _PREHASH_HostName; +extern char const* const _PREHASH_PriceParcelClaim; +extern char const* const _PREHASH_ParcelClaim; +extern char const* const _PREHASH_AgentPowers; +extern char const* const _PREHASH_ProfileHollow; +extern char const* const _PREHASH_GroupRoleChanges; +extern char const* const _PREHASH_Count; +extern char const* const _PREHASH_South; +extern char const* const _PREHASH_ObjectUpdateCompressed; +extern char const* const _PREHASH_MuteFlags; +extern char const* const _PREHASH_Group; +extern char const* const _PREHASH_AgentPause; +extern char const* const _PREHASH_LanguagesText; +extern char const* const _PREHASH_Error; +extern char const* const _PREHASH_InternalScriptMail; +extern char const* const _PREHASH_FindAgent; +extern char const* const _PREHASH_AgentData; +extern char const* const _PREHASH_FolderData; +extern char const* const _PREHASH_AssetBlock; +extern char const* const _PREHASH_AcceptNotices; +extern char const* const _PREHASH_SetGroupAcceptNotices; +extern char const* const _PREHASH_CloseCircuit; +extern char const* const _PREHASH_TeleportFinish; +extern char const* const _PREHASH_PathRevolutions; +extern char const* const _PREHASH_ClassifiedInfoReply; +extern char const* const _PREHASH_ParcelInfoReply; +extern char const* const _PREHASH_AutosaveData; +extern char const* const _PREHASH_SetStartLocation; +extern char const* const _PREHASH_PassHours; +extern char const* const _PREHASH_AttachmentPt; +extern char const* const _PREHASH_ParcelFlags; +extern char const* const _PREHASH_NumVotes; +extern char const* const _PREHASH_AvatarPickerRequest; +extern char const* const _PREHASH_TeleportLocationRequest; +extern char const* const _PREHASH_DataHomeLocationRequest; +extern char const* const _PREHASH_EventNotificationAddRequest; +extern char const* const _PREHASH_ParcelDwellRequest; +extern char const* const _PREHASH_EventLocationRequest; +extern char const* const _PREHASH_SetStartLocationRequest; +extern char const* const _PREHASH_QueryStart; +extern char const* const _PREHASH_EjectData; +extern char const* const _PREHASH_AvatarTextureUpdate; +extern char const* const _PREHASH_RPCServerPort; +extern char const* const _PREHASH_Bytes; +extern char const* const _PREHASH_Extra; +extern char const* const _PREHASH_ForceScriptControlRelease; +extern char const* const _PREHASH_ParcelRelease; +extern char const* const _PREHASH_VFileType; +extern char const* const _PREHASH_EjectGroupMemberReply; +extern char const* const _PREHASH_ImageData; +extern char const* const _PREHASH_SimulatorViewerTimeMessage; +extern char const* const _PREHASH_Rotation; +extern char const* const _PREHASH_Selection; +extern char const* const _PREHASH_TransactionData; +extern char const* const _PREHASH_OperationData; +extern char const* const _PREHASH_ExpirationDate; +extern char const* const _PREHASH_ParcelDeedToGroup; +extern char const* const _PREHASH_AvatarPicksReply; +extern char const* const _PREHASH_GroupTitlesReply; +extern char const* const _PREHASH_AgentInfo; +extern char const* const _PREHASH_MoneyTransferBackend; +extern char const* const _PREHASH_NextOwnerMask; +extern char const* const _PREHASH_MuteData; +extern char const* const _PREHASH_PassPrice; +extern char const* const _PREHASH_SourceID; +extern char const* const _PREHASH_ChangeUserRights; +extern char const* const _PREHASH_TeleportFlags; +extern char const* const _PREHASH_SlaveParcelData; +extern char const* const _PREHASH_AssetData; +extern char const* const _PREHASH_MultipleObjectUpdate; +extern char const* const _PREHASH_ObjectUpdate; +extern char const* const _PREHASH_ImprovedTerseObjectUpdate; +extern char const* const _PREHASH_ConfirmXferPacket; +extern char const* const _PREHASH_StartPingCheck; +extern char const* const _PREHASH_SimWideDeletes; +extern char const* const _PREHASH_LandStatReply; +extern char const* const _PREHASH_IsPhantom; +extern char const* const _PREHASH_AgentList; +extern char const* const _PREHASH_SimApproved; +extern char const* const _PREHASH_RezObject; +extern char const* const _PREHASH_TaskLocalID; +extern char const* const _PREHASH_ClaimDate; +extern char const* const _PREHASH_MergeParcel; +extern char const* const _PREHASH_Priority; +extern char const* const _PREHASH_QueryText; +extern char const* const _PREHASH_GroupNoticeAdd; +extern char const* const _PREHASH_ReturnType; +extern char const* const _PREHASH_FetchFolders; +extern char const* const _PREHASH_SimulatorPublicHostBlock; +extern char const* const _PREHASH_HeaderData; +extern char const* const _PREHASH_RequestMultipleObjects; +extern char const* const _PREHASH_RetrieveInstantMessages; +extern char const* const _PREHASH_OpenCircuit; +extern char const* const _PREHASH_CrossedRegion; +extern char const* const _PREHASH_DirGroupsReply; +extern char const* const _PREHASH_AvatarGroupsReply; +extern char const* const _PREHASH_EmailMessageReply; +extern char const* const _PREHASH_GroupVoteHistoryItemReply; +extern char const* const _PREHASH_ViewerPosition; +extern char const* const _PREHASH_Position; +extern char const* const _PREHASH_ParentEstate; +extern char const* const _PREHASH_EstateName; +extern char const* const _PREHASH_MuteName; +extern char const* const _PREHASH_ParcelRename; +extern char const* const _PREHASH_ViewerFilename; +extern char const* const _PREHASH_UserReportInternal; +extern char const* const _PREHASH_AvatarPropertiesRequest; +extern char const* const _PREHASH_ParcelPropertiesRequest; +extern char const* const _PREHASH_GroupProfileRequest; +extern char const* const _PREHASH_AgentDataUpdateRequest; +extern char const* const _PREHASH_PriceObjectScaleFactor; +extern char const* const _PREHASH_OpenEnrollment; +extern char const* const _PREHASH_GroupData; +extern char const* const _PREHASH_RequestGodlikePowers; +extern char const* const _PREHASH_GrantGodlikePowers; +extern char const* const _PREHASH_TransactionID; +extern char const* const _PREHASH_DestinationID; +extern char const* const _PREHASH_Controls; +extern char const* const _PREHASH_FirstDetachAll; +extern char const* const _PREHASH_EstateID; +extern char const* const _PREHASH_ImprovedInstantMessage; +extern char const* const _PREHASH_CheckParcelSales; +extern char const* const _PREHASH_ParcelSales; +extern char const* const _PREHASH_CurrentInterval; +extern char const* const _PREHASH_PriceRentLight; +extern char const* const _PREHASH_MediaAutoScale; +extern char const* const _PREHASH_NeighborBlock; +extern char const* const _PREHASH_LayerData; +extern char const* const _PREHASH_NVPairData; +extern char const* const _PREHASH_TeleportLocal; +extern char const* const _PREHASH_EjecteeID; +extern char const* const _PREHASH_VoteInitiator; +extern char const* const _PREHASH_TypeData; +extern char const* const _PREHASH_OwnerIDs; +extern char const* const _PREHASH_SystemKickUser; +extern char const* const _PREHASH_TransactionTime; +extern char const* const _PREHASH_TimeToLive; +extern char const* const _PREHASH_OldAgentID; +extern char const* const _PREHASH_MusicURL; +extern char const* const _PREHASH_ParcelPrimBonus; +extern char const* const _PREHASH_EjectUser; +extern char const* const _PREHASH_CoarseLocationUpdate; +extern char const* const _PREHASH_ChildAgentPositionUpdate; +extern char const* const _PREHASH_StoreLocal; +extern char const* const _PREHASH_GroupName; +extern char const* const _PREHASH_PriceParcelRent; +extern char const* const _PREHASH_SimStatus; +extern char const* const _PREHASH_TransactionSuccess; +extern char const* const _PREHASH_LureType; +extern char const* const _PREHASH_GroupMask; +extern char const* const _PREHASH_SitObject; +extern char const* const _PREHASH_Override; +extern char const* const _PREHASH_LocomotionState; +extern char const* const _PREHASH_PriceUpload; +extern char const* const _PREHASH_RemoveParcel; +extern char const* const _PREHASH_ConfirmAuctionStart; +extern char const* const _PREHASH_RpcScriptRequestInbound; +extern char const* const _PREHASH_ActiveGroupID; +extern char const* const _PREHASH_ParcelReturnObjects; +extern char const* const _PREHASH_TotalObjects; +extern char const* const _PREHASH_ObjectExtraParams; +extern char const* const _PREHASH_Questions; +extern char const* const _PREHASH_TransferAbort; +extern char const* const _PREHASH_TransferInventory; +extern char const* const _PREHASH_RayTargetID; +extern char const* const _PREHASH_ClaimPrice; +extern char const* const _PREHASH_ObjectProperties; +extern char const* const _PREHASH_ParcelProperties; +extern char const* const _PREHASH_EstateOwnerID; +extern char const* const _PREHASH_LogoutRequest; +extern char const* const _PREHASH_AssetUploadRequest; +extern char const* const _PREHASH_TransactionType; +extern char const* const _PREHASH_AvatarPropertiesUpdate; +extern char const* const _PREHASH_ParcelPropertiesUpdate; +extern char const* const _PREHASH_FetchItems; +extern char const* const _PREHASH_AbortXfer; +extern char const* const _PREHASH_DeRezAck; +extern char const* const _PREHASH_TakeControls; +extern char const* const _PREHASH_DirLandReply; +extern char const* const _PREHASH_MuteType; +extern char const* const _PREHASH_IMViaEMail; +extern char const* const _PREHASH_RentPrice; +extern char const* const _PREHASH_GenericMessage; +extern char const* const _PREHASH_ChildAgentAlive; +extern char const* const _PREHASH_AssetType; +extern char const* const _PREHASH_SpawnPointBlock; +extern char const* const _PREHASH_AttachmentBlock; +extern char const* const _PREHASH_ObjectMaterial; +extern char const* const _PREHASH_OwnerName; +extern char const* const _PREHASH_AvatarNotesReply; +extern char const* const _PREHASH_CacheID; +extern char const* const _PREHASH_OwnerMask; +extern char const* const _PREHASH_TransferInventoryAck; +extern char const* const _PREHASH_RegionDenyAgeUnverified; +extern char const* const _PREHASH_AgeVerificationBlock; +extern char const* const _PREHASH_UCoord; +extern char const* const _PREHASH_VCoord; +extern char const* const _PREHASH_FaceIndex; +extern char const* const _PREHASH_StatusData; +extern char const* const _PREHASH_ProductSKU; +extern char const* const _PREHASH_SeeAVs; +extern char const* const _PREHASH_AnyAVSounds; +extern char const* const _PREHASH_GroupAVSounds; #endif diff --git a/indra/llmessage/net.cpp b/indra/llmessage/net.cpp index 97611c3b51..85aef5da00 100644 --- a/indra/llmessage/net.cpp +++ b/indra/llmessage/net.cpp @@ -50,7 +50,6 @@ #include "lltimer.h" #include "indra_constants.h" - // Globals #if LL_WINDOWS @@ -174,7 +173,7 @@ U32 ip_string_to_u32(const char* ip_string) // use wildcard addresses. -Ambroff U32 ip = inet_addr(ip_string); if (ip == INADDR_NONE - && strncmp(ip_string, BROADCAST_ADDRESS_STRING, MAXADDRSTR) != 0) + && strncmp(ip_string, BROADCAST_ADDRESS_STRING, MAXADDRSTR) != 0) { llwarns << "ip_string_to_u32() failed, Error: Invalid IP string '" << ip_string << "'" << llendl; return INVALID_HOST_IP_ADDRESS; @@ -188,11 +187,11 @@ U32 ip_string_to_u32(const char* ip_string) ////////////////////////////////////////////////////////////////////////////////////////// #if LL_WINDOWS - + S32 start_net(S32& socket_out, int& nPort) { // Create socket, make non-blocking - // Init WinSock + // Init WinSock int nRet; int hSocket; @@ -201,7 +200,7 @@ S32 start_net(S32& socket_out, int& nPort) int buff_size = 4; // Initialize windows specific stuff - if(WSAStartup(0x0202, &stWSAData)) + if (WSAStartup(0x0202, &stWSAData)) { S32 err = WSAGetLastError(); WSACleanup(); @@ -210,8 +209,8 @@ S32 start_net(S32& socket_out, int& nPort) } // Get a datagram socket - hSocket = (int)socket(AF_INET, SOCK_DGRAM, 0); - if (hSocket == INVALID_SOCKET) + hSocket = (int)socket(AF_INET, SOCK_DGRAM, 0); + if (hSocket == INVALID_SOCKET) { S32 err = WSAGetLastError(); WSACleanup(); @@ -304,7 +303,7 @@ S32 start_net(S32& socket_out, int& nPort) // Setup a destination address stDstAddr.sin_family = AF_INET; stDstAddr.sin_addr.s_addr = INVALID_HOST_IP_ADDRESS; - stDstAddr.sin_port = htons(nPort); + stDstAddr.sin_port = htons(nPort); socket_out = hSocket; return 0; @@ -393,10 +392,10 @@ S32 start_net(S32& socket_out, int& nPort) int rec_size = RECEIVE_BUFFER_SIZE; socklen_t buff_size = 4; - + // Create socket - hSocket = socket(AF_INET, SOCK_DGRAM, 0); - if (hSocket < 0) + hSocket = socket(AF_INET, SOCK_DGRAM, 0); + if (hSocket < 0) { llwarns << "socket() failed" << llendl; return 1; @@ -429,7 +428,7 @@ S32 start_net(S32& socket_out, int& nPort) } else { - // Name the socket (assign the local port number to receive on) + // Name the socket (assign the local port number to receive on) stLclAddr.sin_family = AF_INET; stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY); stLclAddr.sin_port = htons(nPort); @@ -474,7 +473,7 @@ S32 start_net(S32& socket_out, int& nPort) nPort = attempt_port; } // Set socket to be non-blocking - fcntl(hSocket, F_SETFL, O_NONBLOCK); + fcntl(hSocket, F_SETFL, O_NONBLOCK); // set a large receive buffer nRet = setsockopt(hSocket, SOL_SOCKET, SO_RCVBUF, (char *)&rec_size, buff_size); if (nRet) @@ -510,8 +509,8 @@ S32 start_net(S32& socket_out, int& nPort) // Setup a destination address char achMCAddr[MAXADDRSTR] = "127.0.0.1"; /* Flawfinder: ignore */ stDstAddr.sin_family = AF_INET; - stDstAddr.sin_addr.s_addr = ip_string_to_u32(achMCAddr); - stDstAddr.sin_port = htons(nPort); + stDstAddr.sin_addr.s_addr = ip_string_to_u32(achMCAddr); + stDstAddr.sin_port = htons(nPort); socket_out = hSocket; return 0; @@ -537,7 +536,7 @@ static int recvfrom_destip( int socket, void *buf, int len, struct sockaddr *fro iov[0].iov_base = buf; iov[0].iov_len = len; - memset( &msg, 0, sizeof msg ); + memset(&msg, 0, sizeof msg); msg.msg_name = from; msg.msg_namelen = *fromlen; msg.msg_iov = iov; @@ -545,14 +544,14 @@ static int recvfrom_destip( int socket, void *buf, int len, struct sockaddr *fro msg.msg_control = &cmsg; msg.msg_controllen = sizeof(cmsg); - size = recvmsg( socket, &msg, 0 ); + size = recvmsg(socket, &msg, 0); - if( size == -1 ) + if (size == -1) { return -1; } - for( cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR( &msg, cmsgptr ) ) + for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR( &msg, cmsgptr)) { if( cmsgptr->cmsg_level == SOL_IP && cmsgptr->cmsg_type == IP_PKTINFO ) { @@ -650,7 +649,7 @@ BOOL send_packet(int hSocket, const char * sendBuffer, int size, U32 recipient, } } } - while ( resend && send_attempts < 3); + while (resend && send_attempts < 3); if (send_attempts >= 3) { diff --git a/indra/llmessage/net.h b/indra/llmessage/net.h index 9f4f5c5821..0f2437479d 100644 --- a/indra/llmessage/net.h +++ b/indra/llmessage/net.h @@ -46,10 +46,10 @@ S32 receive_packet(int hSocket, char * receiveBuffer); BOOL send_packet(int hSocket, const char *sendBuffer, int size, U32 recipient, int nPort); // Returns TRUE on success. //void get_sender(char * tmp); -LLHost get_sender(); +LLHost get_sender(); U32 get_sender_port(); U32 get_sender_ip(void); -LLHost get_receiving_interface(); +LLHost get_receiving_interface(); U32 get_receiving_interface_ip(void); const char* u32_to_ip_string(U32 ip); // Returns pointer to internal string buffer, "(bad IP addr)" on failure, cannot nest calls diff --git a/indra/llmessage/tests/commtest.h b/indra/llmessage/tests/commtest.h index 32035783e2..0d149b5258 100644 --- a/indra/llmessage/tests/commtest.h +++ b/indra/llmessage/tests/commtest.h @@ -34,7 +34,67 @@ #include "llsd.h" #include "llhost.h" #include "stringize.h" +#include <map> #include <string> +#include <stdexcept> +#include <boost/lexical_cast.hpp> + +struct CommtestError: public std::runtime_error +{ + CommtestError(const std::string& what): std::runtime_error(what) {} +}; + +static bool query_verbose() +{ + const char* cbose = getenv("INTEGRATION_TEST_VERBOSE"); + if (! cbose) + { + cbose = "1"; + } + std::string strbose(cbose); + return (! (strbose == "0" || strbose == "off" || + strbose == "false" || strbose == "quiet")); +} + +bool verbose() +{ + // This should only be initialized once. + static bool vflag = query_verbose(); + return vflag; +} + +static int query_port(const std::string& var) +{ + const char* cport = getenv(var.c_str()); + if (! cport) + { + throw CommtestError(STRINGIZE("missing environment variable" << var)); + } + // This will throw, too, if the value of PORT isn't numeric. + int port(boost::lexical_cast<int>(cport)); + if (verbose()) + { + std::cout << "getport('" << var << "') = " << port << std::endl; + } + return port; +} + +static int getport(const std::string& var) +{ + typedef std::map<std::string, int> portsmap; + static portsmap ports; + // We can do this with a single map lookup with map::insert(). Either it + // returns an existing entry and 'false' (not newly inserted), or it + // inserts the specified value and 'true'. + std::pair<portsmap::iterator, bool> inserted(ports.insert(portsmap::value_type(var, 0))); + if (inserted.second) + { + // We haven't yet seen this var. Remember its value. + inserted.first->second = query_port(var); + } + // Return the (existing or new) iterator's value. + return inserted.first->second; +} /** * This struct is shared by a couple of standalone comm tests (ADD_COMM_BUILD_TEST). @@ -55,13 +115,21 @@ struct commtest_data replyPump("reply"), errorPump("error"), success(false), - host("127.0.0.1", 8000), + host("127.0.0.1", getport("PORT")), server(STRINGIZE("http://" << host.getString() << "/")) { replyPump.listen("self", boost::bind(&commtest_data::outcome, this, _1, true)); errorPump.listen("self", boost::bind(&commtest_data::outcome, this, _1, false)); } + static int getport(const std::string& var) + { + // We have a couple consumers of commtest_data::getport(). But we've + // since moved it out to the global namespace. So this is just a + // facade. + return ::getport(var); + } + bool outcome(const LLSD& _result, bool _success) { // std::cout << "commtest_data::outcome(" << _result << ", " << _success << ")\n"; diff --git a/indra/llmessage/tests/llhost_test.cpp b/indra/llmessage/tests/llhost_test.cpp index b20bceae1d..eadf83c428 100644 --- a/indra/llmessage/tests/llhost_test.cpp +++ b/indra/llmessage/tests/llhost_test.cpp @@ -151,8 +151,9 @@ namespace tut template<> template<> void host_object::test<9>() { + skip("this test is flaky, but we should figure out why..."); // skip("setHostByName(\"google.com\"); getHostName() -> (e.g.) \"yx-in-f100.1e100.net\""); - std::string hostStr = "linux.org"; + std::string hostStr = "lindenlab.com"; LLHost host; host.setHostByName(hostStr); diff --git a/indra/llmessage/tests/llsdmessage_test.cpp b/indra/llmessage/tests/llsdmessage_test.cpp index 9998a1b8bb..0f2c069303 100644 --- a/indra/llmessage/tests/llsdmessage_test.cpp +++ b/indra/llmessage/tests/llsdmessage_test.cpp @@ -61,6 +61,7 @@ namespace tut llsdmessage_data(): httpPump(pumps.obtain("LLHTTPClient")) { + LLCurl::initClass(); LLSDMessage::link(); } }; diff --git a/indra/llmessage/tests/test_llsdmessage_peer.py b/indra/llmessage/tests/test_llsdmessage_peer.py index 7eb198bb34..22edd9dad8 100644 --- a/indra/llmessage/tests/test_llsdmessage_peer.py +++ b/indra/llmessage/tests/test_llsdmessage_peer.py @@ -1,4 +1,4 @@ -#!/usr/bin/python +#!/usr/bin/env python """\ @file test_llsdmessage_peer.py @author Nat Goodspeed @@ -38,7 +38,7 @@ mydir = os.path.dirname(__file__) # expected to be .../indra/llmessage/tes sys.path.insert(0, os.path.join(mydir, os.pardir, os.pardir, "lib", "python")) from indra.util.fastest_elementtree import parse as xml_parse from indra.base import llsd -from testrunner import run, debug +from testrunner import freeport, run, debug, VERBOSE class TestHTTPRequestHandler(BaseHTTPRequestHandler): """This subclass of BaseHTTPRequestHandler is to receive and echo @@ -72,10 +72,10 @@ class TestHTTPRequestHandler(BaseHTTPRequestHandler): ## # assuming that the underlying XML parser reads its input file ## # incrementally. Unfortunately I haven't been able to make it work. ## tree = xml_parse(self.rfile) -## debug("Finished raw parse\n") -## debug("parsed XML tree %s\n" % tree) -## debug("parsed root node %s\n" % tree.getroot()) -## debug("root node tag %s\n" % tree.getroot().tag) +## debug("Finished raw parse") +## debug("parsed XML tree %s", tree) +## debug("parsed root node %s", tree.getroot()) +## debug("root node tag %s", tree.getroot().tag) ## return llsd.to_python(tree.getroot()) def do_GET(self): @@ -88,8 +88,10 @@ class TestHTTPRequestHandler(BaseHTTPRequestHandler): self.answer(self.read_xml()) def answer(self, data): + debug("%s.answer(%s): self.path = %r", self.__class__.__name__, data, self.path) if "fail" not in self.path: response = llsd.format_xml(data.get("reply", llsd.LLSD("success"))) + debug("success: %s", response) self.send_response(200) self.send_header("Content-type", "application/llsd+xml") self.send_header("Content-Length", str(len(response))) @@ -97,27 +99,48 @@ class TestHTTPRequestHandler(BaseHTTPRequestHandler): self.wfile.write(response) else: # fail requested status = data.get("status", 500) + # self.responses maps an int status to a (short, long) pair of + # strings. We want the longer string. That's why we pass a string + # pair to get(): the [1] will select the second string, whether it + # came from self.responses or from our default pair. reason = data.get("reason", self.responses.get(status, ("fail requested", "Your request specified failure status %s " "without providing a reason" % status))[1]) + debug("fail requested: %s: %r", status, reason) self.send_error(status, reason) - def log_request(self, code, size=None): - # For present purposes, we don't want the request splattered onto - # stderr, as it would upset devs watching the test run - pass + if not VERBOSE: + # When VERBOSE is set, skip both these overrides because they exist to + # suppress output. - def log_error(self, format, *args): - # Suppress error output as well - pass + def log_request(self, code, size=None): + # For present purposes, we don't want the request splattered onto + # stderr, as it would upset devs watching the test run + pass -class TestHTTPServer(Thread): - def run(self): - httpd = HTTPServer(('127.0.0.1', 8000), TestHTTPRequestHandler) - debug("Starting HTTP server...\n") - httpd.serve_forever() + def log_error(self, format, *args): + # Suppress error output as well + pass + +class Server(HTTPServer): + # This pernicious flag is on by default in HTTPServer. But proper + # operation of freeport() absolutely depends on it being off. + allow_reuse_address = False if __name__ == "__main__": - sys.exit(run(server=TestHTTPServer(name="httpd"), *sys.argv[1:])) + # Instantiate a Server(TestHTTPRequestHandler) on the first free port + # in the specified port range. Doing this inline is better than in a + # daemon thread: if it blows up here, we'll get a traceback. If it blew up + # in some other thread, the traceback would get eaten and we'd run the + # subject test program anyway. + httpd, port = freeport(xrange(8000, 8020), + lambda port: Server(('127.0.0.1', port), TestHTTPRequestHandler)) + # Pass the selected port number to the subject test program via the + # environment. We don't want to impose requirements on the test program's + # command-line parsing -- and anyway, for C++ integration tests, that's + # performed in TUT code rather than our own. + os.environ["PORT"] = str(port) + debug("$PORT = %s", port) + sys.exit(run(server=Thread(name="httpd", target=httpd.serve_forever), *sys.argv[1:])) diff --git a/indra/llmessage/tests/testrunner.py b/indra/llmessage/tests/testrunner.py index 4d58ef7130..f2c841532a 100644 --- a/indra/llmessage/tests/testrunner.py +++ b/indra/llmessage/tests/testrunner.py @@ -1,4 +1,4 @@ -#!/usr/bin/python +#!/usr/bin/env python """\ @file testrunner.py @author Nat Goodspeed @@ -27,14 +27,118 @@ Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA $/LicenseInfo$ """ +from __future__ import with_statement + import os import sys +import re +import errno +import socket + +VERBOSE = os.environ.get("INTEGRATION_TEST_VERBOSE", "1") # default to verbose +# Support usage such as INTEGRATION_TEST_VERBOSE=off -- distressing to user if +# that construct actually turns on verbosity... +VERBOSE = not re.match(r"(0|off|false|quiet)$", VERBOSE, re.IGNORECASE) + +if VERBOSE: + def debug(fmt, *args): + print fmt % args + sys.stdout.flush() +else: + debug = lambda *args: None + +def freeport(portlist, expr): + """ + Find a free server port to use. Specifically, evaluate 'expr' (a + callable(port)) until it stops raising EADDRINUSE exception. + + Pass: + + portlist: an iterable (e.g. xrange()) of ports to try. If you exhaust the + range, freeport() lets the socket.error exception propagate. If you want + unbounded, you could pass itertools.count(baseport), though of course in + practice the ceiling is 2^16-1 anyway. But it seems prudent to constrain + the range much more sharply: if we're iterating an absurd number of times, + probably something else is wrong. + + expr: a callable accepting a port number, specifically one of the items + from portlist. If calling that callable raises socket.error with + EADDRINUSE, freeport() retrieves the next item from portlist and retries. + + Returns: (expr(port), port) + + port: the value from portlist for which expr(port) succeeded + + Raises: + + Any exception raised by expr(port) other than EADDRINUSE. + + socket.error if, for every item from portlist, expr(port) raises + socket.error. The exception you see is the one from the last item in + portlist. + + StopIteration if portlist is completely empty. + + Example: + + class Server(HTTPServer): + # If you use BaseHTTPServer.HTTPServer, turning off this flag is + # essential for proper operation of freeport()! + allow_reuse_address = False + # ... + server, port = freeport(xrange(8000, 8010), + lambda port: Server(("localhost", port), + MyRequestHandler)) + # pass 'port' to client code + # call server.serve_forever() + """ + try: + # If portlist is completely empty, let StopIteration propagate: that's an + # error because we can't return meaningful values. We have no 'port', + # therefore no 'expr(port)'. + portiter = iter(portlist) + port = portiter.next() + + while True: + try: + # If this value of port works, return as promised. + value = expr(port) + + except socket.error, err: + # Anything other than 'Address already in use', propagate + if err.args[0] != errno.EADDRINUSE: + raise + + # Here we want the next port from portiter. But on StopIteration, + # we want to raise the original exception rather than + # StopIteration. So save the original exc_info(). + type, value, tb = sys.exc_info() + try: + try: + port = portiter.next() + except StopIteration: + raise type, value, tb + finally: + # Clean up local traceback, see docs for sys.exc_info() + del tb + + else: + debug("freeport() returning %s on port %s", value, port) + return value, port -def debug(*args): - sys.stdout.writelines(args) - sys.stdout.flush() -# comment out the line below to enable debug output -debug = lambda *args: None + # Recap of the control flow above: + # If expr(port) doesn't raise, return as promised. + # If expr(port) raises anything but EADDRINUSE, propagate that + # exception. + # If portiter.next() raises StopIteration -- that is, if the port + # value we just passed to expr(port) was the last available -- reraise + # the EADDRINUSE exception. + # If we've actually arrived at this point, portiter.next() delivered a + # new port value. Loop back to pass that to expr(port). + + except Exception, err: + debug("*** freeport() raising %s: %s", err.__class__.__name__, err) + raise def run(*args, **kwds): """All positional arguments collectively form a command line, executed as @@ -63,8 +167,96 @@ def run(*args, **kwds): # - [no p] don't use the PATH because we specifically want to invoke the # executable passed as our first arg, # - [no e] child should inherit this process's environment. - debug("Running %s...\n" % (" ".join(args))) - sys.stdout.flush() + debug("Running %s...", " ".join(args)) rc = os.spawnv(os.P_WAIT, args[0], args) - debug("%s returned %s\n" % (args[0], rc)) + debug("%s returned %s", args[0], rc) return rc + +# **************************************************************************** +# test code -- manual at this point, see SWAT-564 +# **************************************************************************** +def test_freeport(): + # ------------------------------- Helpers -------------------------------- + from contextlib import contextmanager + # helper Context Manager for expecting an exception + # with exc(SomeError): + # raise SomeError() + # raises AssertionError otherwise. + @contextmanager + def exc(exception_class, *args): + try: + yield + except exception_class, err: + for i, expected_arg in enumerate(args): + assert expected_arg == err.args[i], \ + "Raised %s, but args[%s] is %r instead of %r" % \ + (err.__class__.__name__, i, err.args[i], expected_arg) + print "Caught expected exception %s(%s)" % \ + (err.__class__.__name__, ', '.join(repr(arg) for arg in err.args)) + else: + assert False, "Failed to raise " + exception_class.__class__.__name__ + + # helper to raise specified exception + def raiser(exception): + raise exception + + # the usual + def assert_equals(a, b): + assert a == b, "%r != %r" % (a, b) + + # ------------------------ Sanity check the above ------------------------ + class SomeError(Exception): pass + # Without extra args, accept any err.args value + with exc(SomeError): + raiser(SomeError("abc")) + # With extra args, accept only the specified value + with exc(SomeError, "abc"): + raiser(SomeError("abc")) + with exc(AssertionError): + with exc(SomeError, "abc"): + raiser(SomeError("def")) + with exc(AssertionError): + with exc(socket.error, errno.EADDRINUSE): + raiser(socket.error(errno.ECONNREFUSED, 'Connection refused')) + + # ----------- freeport() without engaging socket functionality ----------- + # If portlist is empty, freeport() raises StopIteration. + with exc(StopIteration): + freeport([], None) + + assert_equals(freeport([17], str), ("17", 17)) + + # This is the magic exception that should prompt us to retry + inuse = socket.error(errno.EADDRINUSE, 'Address already in use') + # Get the iterator to our ports list so we can check later if we've used all + ports = iter(xrange(5)) + with exc(socket.error, errno.EADDRINUSE): + freeport(ports, lambda port: raiser(inuse)) + # did we entirely exhaust 'ports'? + with exc(StopIteration): + ports.next() + + ports = iter(xrange(2)) + # Any exception but EADDRINUSE should quit immediately + with exc(SomeError): + freeport(ports, lambda port: raiser(SomeError())) + assert_equals(ports.next(), 1) + + # ----------- freeport() with platform-dependent socket stuff ------------ + # This is what we should've had unit tests to begin with (see CHOP-661). + def newbind(port): + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.bind(('127.0.0.1', port)) + return sock + + bound0, port0 = freeport(xrange(7777, 7780), newbind) + assert_equals(port0, 7777) + bound1, port1 = freeport(xrange(7777, 7780), newbind) + assert_equals(port1, 7778) + bound2, port2 = freeport(xrange(7777, 7780), newbind) + assert_equals(port2, 7779) + with exc(socket.error, errno.EADDRINUSE): + bound3, port3 = freeport(xrange(7777, 7780), newbind) + +if __name__ == "__main__": + test_freeport() |