/** * @file llcachename.cpp * @brief A hierarchical cache of first and last names queried based on UUID. * * $LicenseInfo:firstyear=2002&license=viewergpl$ * * Copyright (c) 2002-2007, Linden Research, Inc. * * Second Life Viewer Source Code * The source code in this file ("Source Code") is provided by Linden Lab * to you under the terms of the GNU General Public License, version 2.0 * ("GPL"), unless you have obtained a separate licensing agreement * ("Other License"), formally executed by you and Linden Lab. Terms of * the GPL can be found in doc/GPL-license.txt in this distribution, or * online at http://secondlife.com/developers/opensource/gplv2 * * There are special exceptions to the terms and conditions of the GPL as * it is applied to this Source Code. View the full text of the exception * in the file doc/FLOSS-exception.txt in this software distribution, or * online at http://secondlife.com/developers/opensource/flossexception * * By copying, modifying or distributing this software, you acknowledge * that you have read and understood your obligations described above, * and agree to abide by those obligations. * * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, * COMPLETENESS OR PERFORMANCE. * $/LicenseInfo$ */ #include "linden_common.h" #include "llcachename.h" // linden library includes #include "lldbstrings.h" #include "llframetimer.h" #include "llhost.h" #include "llrand.h" #include "llsdserialize.h" #include "lluuid.h" #include "message.h" // Constants // probably need a setUIString() call in the interface const char* const CN_WAITING = "(Loading...)"; // *TODO: translate const char* const CN_NOBODY = "(nobody)"; // *TODO: translate const char* const CN_NONE = "(none)"; // *TODO: translate // llsd serialization constants static const std::string AGENTS("agents"); static const std::string GROUPS("groups"); static const std::string CTIME("ctime"); static const std::string FIRST("first"); static const std::string LAST("last"); static const std::string NAME("name"); // We track name requests in flight for up to this long. // We won't re-request a name during this time const U32 PENDING_TIMEOUT_SECS = 5 * 60; // File version number const S32 CN_FILE_VERSION = 2; // Globals LLCacheName* gCacheName = NULL; /// --------------------------------------------------------------------------- /// class LLCacheNameEntry /// --------------------------------------------------------------------------- class LLCacheNameEntry { public: LLCacheNameEntry(); public: bool mIsGroup; U32 mCreateTime; // unix time_t char mFirstName[DB_FIRST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/ char mLastName[DB_LAST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/ char mGroupName[DB_GROUP_NAME_BUF_SIZE]; /*Flawfinder: ignore*/ }; LLCacheNameEntry::LLCacheNameEntry() { mFirstName[0] = '\0'; mLastName[0] = '\0'; mGroupName[0] = '\0'; } class PendingReply { public: LLUUID mID; LLCacheNameCallback mCallback; LLHost mHost; void* mData; PendingReply(const LLUUID& id, LLCacheNameCallback callback, void* data = NULL) : mID(id), mCallback(callback), mData(data) { } PendingReply(const LLUUID& id, const LLHost& host) : mID(id), mCallback(0), mHost(host) { } void done() { mID.setNull(); } bool isDone() const { return mID.isNull() != FALSE; } }; class ReplySender { public: ReplySender(LLMessageSystem* msg); ~ReplySender(); void send(const LLUUID& id, const LLCacheNameEntry& entry, const LLHost& host); private: void flush(); LLMessageSystem* mMsg; bool mPending; bool mCurrIsGroup; LLHost mCurrHost; }; ReplySender::ReplySender(LLMessageSystem* msg) : mMsg(msg), mPending(false) { } ReplySender::~ReplySender() { flush(); } void ReplySender::send(const LLUUID& id, const LLCacheNameEntry& entry, const LLHost& host) { if (mPending) { if (mCurrIsGroup != entry.mIsGroup || mCurrHost != host) { flush(); } } if (!mPending) { mPending = true; mCurrIsGroup = entry.mIsGroup; mCurrHost = host; if(mCurrIsGroup) mMsg->newMessageFast(_PREHASH_UUIDGroupNameReply); else mMsg->newMessageFast(_PREHASH_UUIDNameReply); } mMsg->nextBlockFast(_PREHASH_UUIDNameBlock); mMsg->addUUIDFast(_PREHASH_ID, id); if(mCurrIsGroup) { mMsg->addStringFast(_PREHASH_GroupName, entry.mGroupName); } else { mMsg->addStringFast(_PREHASH_FirstName, entry.mFirstName); mMsg->addStringFast(_PREHASH_LastName, entry.mLastName); } if(mMsg->isSendFullFast(_PREHASH_UUIDNameBlock)) { flush(); } } void ReplySender::flush() { if (mPending) { mMsg->sendReliable(mCurrHost); mPending = false; } } typedef std::set AskQueue; typedef std::vector ReplyQueue; typedef std::map PendingQueue; typedef std::map Cache; typedef std::vector Observers; class LLCacheName::Impl { public: LLMessageSystem* mMsg; LLHost mUpstreamHost; Cache mCache; // the map of UUIDs to names AskQueue mAskNameQueue; AskQueue mAskGroupQueue; // UUIDs to ask our upstream host about PendingQueue mPendingQueue; // UUIDs that have been requested but are not in cache yet. ReplyQueue mReplyQueue; // requests awaiting replies from us Observers mObservers; LLFrameTimer mProcessTimer; Impl(LLMessageSystem* msg); ~Impl(); void processPendingAsks(); void processPendingReplies(); void sendRequest(const char* msg_name, const AskQueue& queue); bool isRequestPending(const LLUUID& id); // Message system callbacks. void processUUIDRequest(LLMessageSystem* msg, bool isGroup); void processUUIDReply(LLMessageSystem* msg, bool isGroup); static void handleUUIDNameRequest(LLMessageSystem* msg, void** userdata); static void handleUUIDNameReply(LLMessageSystem* msg, void** userdata); static void handleUUIDGroupNameRequest(LLMessageSystem* msg, void** userdata); static void handleUUIDGroupNameReply(LLMessageSystem* msg, void** userdata); void notifyObservers(const LLUUID& id, const char* first, const char* last, BOOL group); }; /// -------------------------------------------------------------------------- /// class LLCacheName /// --------------------------------------------------------------------------- LLCacheName::LLCacheName(LLMessageSystem* msg) : impl(* new Impl(msg)) { } LLCacheName::LLCacheName(LLMessageSystem* msg, const LLHost& upstream_host) : impl(* new Impl(msg)) { setUpstream(upstream_host); } LLCacheName::~LLCacheName() { delete &impl; } LLCacheName::Impl::Impl(LLMessageSystem* msg) : mMsg(msg), mUpstreamHost(LLHost::invalid) { mMsg->setHandlerFuncFast( _PREHASH_UUIDNameRequest, handleUUIDNameRequest, (void**)this); mMsg->setHandlerFuncFast( _PREHASH_UUIDNameReply, handleUUIDNameReply, (void**)this); mMsg->setHandlerFuncFast( _PREHASH_UUIDGroupNameRequest, handleUUIDGroupNameRequest, (void**)this); mMsg->setHandlerFuncFast( _PREHASH_UUIDGroupNameReply, handleUUIDGroupNameReply, (void**)this); } LLCacheName::Impl::~Impl() { for_each(mCache.begin(), mCache.end(), DeletePairedPointer()); } void LLCacheName::setUpstream(const LLHost& upstream_host) { impl.mUpstreamHost = upstream_host; } void LLCacheName::addObserver(LLCacheNameCallback callback) { impl.mObservers.push_back(callback); } void LLCacheName::removeObserver(LLCacheNameCallback callback) { Observers::iterator it = impl.mObservers.begin(); Observers::iterator end = impl.mObservers.end(); for ( ; it != end; ++it) { const LLCacheNameCallback& cb = (*it); if (cb == callback) { impl.mObservers.erase(it); return; } } } void LLCacheName::cancelCallback(const LLUUID& id, LLCacheNameCallback callback, void* user_data) { ReplyQueue::iterator it = impl.mReplyQueue.begin(); ReplyQueue::iterator end = impl.mReplyQueue.end(); for(; it != end; ++it) { const PendingReply& reply = (*it); if ((callback == reply.mCallback) && (id == reply.mID) && (user_data == reply.mData) ) { impl.mReplyQueue.erase(it); return; } } } void LLCacheName::importFile(LLFILE* fp) { S32 count = 0; const S32 BUFFER_SIZE = 1024; char buffer[BUFFER_SIZE]; /*Flawfinder: ignore*/ // *NOTE: These buffer sizes are hardcoded into sscanf() below char id_string[MAX_STRING]; /*Flawfinder: ignore*/ char firstname[MAX_STRING]; /*Flawfinder: ignore*/ char lastname[MAX_STRING]; /*Flawfinder: ignore*/ U32 create_time; // This is OK if the first line is actually a name. We just don't load it. char* valid = fgets(buffer, BUFFER_SIZE, fp); if (!valid) return; // *NOTE: This buffer size is hardcoded into sscanf() below char version_string[BUFFER_SIZE]; /*Flawfinder: ignore*/ S32 version = 0; S32 match = sscanf( /* Flawfinder: ignore */ buffer, "%1023s %d", version_string, &version); if ( match != 2 || strcmp(version_string, "version") || version != CN_FILE_VERSION) { llwarns << "Ignoring old cache name file format" << llendl; return; } // We'll expire entries more than a week old U32 now = (U32)time(NULL); const U32 SECS_PER_DAY = 60 * 60 * 24; U32 delete_before_time = now - (7 * SECS_PER_DAY); while(!feof(fp)) { valid = fgets(buffer, BUFFER_SIZE, fp); if (!valid) break; match = sscanf( /* Flawfinder: ignore */ buffer, "%254s %u %254s %254s", id_string, &create_time, firstname, lastname); if (4 != match) continue; LLUUID id(id_string); if (id.isNull()) continue; // undo trivial XOR S32 i; for (i = 0; i < UUID_BYTES; i++) { id.mData[i] ^= 0x33; } // Don't load entries that are more than a week old if (create_time < delete_before_time) continue; LLCacheNameEntry* entry = new LLCacheNameEntry(); entry->mIsGroup = false; entry->mCreateTime = create_time; LLString::copy(entry->mFirstName, firstname, DB_FIRST_NAME_BUF_SIZE); LLString::copy(entry->mLastName, lastname, DB_LAST_NAME_BUF_SIZE); impl.mCache[id] = entry; count++; } llinfos << "LLCacheName loaded " << count << " names" << llendl; } bool LLCacheName::importFile(std::istream& istr) { LLSD data; if(LLSDSerialize::fromXML(data, istr) < 1) return false; // We'll expire entries more than a week old U32 now = (U32)time(NULL); const U32 SECS_PER_DAY = 60 * 60 * 24; U32 delete_before_time = now - (7 * SECS_PER_DAY); // iterate over the agents S32 count = 0; LLSD agents = data[AGENTS]; LLSD::map_iterator iter = agents.beginMap(); LLSD::map_iterator end = agents.endMap(); for( ; iter != end; ++iter) { LLUUID id((*iter).first); LLSD agent = (*iter).second; U32 ctime = (U32)agent[CTIME].asInteger(); if(ctime < delete_before_time) continue; LLCacheNameEntry* entry = new LLCacheNameEntry(); entry->mIsGroup = false; entry->mCreateTime = ctime; std::string first = agent[FIRST].asString(); first.copy(entry->mFirstName, DB_FIRST_NAME_BUF_SIZE, 0); entry->mFirstName[llmin(first.size(),(std::string::size_type)DB_FIRST_NAME_BUF_SIZE-1)] = '\0'; std::string last = agent[LAST].asString(); last.copy(entry->mLastName, DB_LAST_NAME_BUF_SIZE, 0); entry->mLastName[llmin(last.size(),(std::string::size_type)DB_LAST_NAME_BUF_SIZE-1)] = '\0'; impl.mCache[id] = entry; ++count; } llinfos << "LLCacheName loaded " << count << " agent names" << llendl; count = 0; LLSD groups = data[GROUPS]; iter = groups.beginMap(); end = groups.endMap(); for( ; iter != end; ++iter) { LLUUID id((*iter).first); LLSD group = (*iter).second; U32 ctime = (U32)group[CTIME].asInteger(); if(ctime < delete_before_time) continue; LLCacheNameEntry* entry = new LLCacheNameEntry(); entry->mIsGroup = true; entry->mCreateTime = ctime; std::string name = group[NAME].asString(); name.copy(entry->mGroupName, DB_GROUP_NAME_BUF_SIZE, 0); entry->mGroupName[llmin(name.size(), (std::string::size_type)DB_GROUP_NAME_BUF_SIZE-1)] = '\0'; impl.mCache[id] = entry; ++count; } llinfos << "LLCacheName loaded " << count << " group names" << llendl; return true; } void LLCacheName::exportFile(std::ostream& ostr) { LLSD data; Cache::iterator iter = impl.mCache.begin(); Cache::iterator end = impl.mCache.end(); for( ; iter != end; ++iter) { // Only write entries for which we have valid data. LLCacheNameEntry* entry = iter->second; if(!entry || (NULL != strchr(entry->mFirstName, '?')) || (NULL != strchr(entry->mGroupName, '?'))) { continue; } // store it LLUUID id = iter->first; std::string id_str = id.asString(); if(entry->mFirstName[0] && entry->mLastName[0]) { data[AGENTS][id_str][FIRST] = entry->mFirstName; data[AGENTS][id_str][LAST] = entry->mLastName; data[AGENTS][id_str][CTIME] = (S32)entry->mCreateTime; } else if(entry->mIsGroup && entry->mGroupName[0]) { data[GROUPS][id_str][NAME] = entry->mGroupName; data[GROUPS][id_str][CTIME] = (S32)entry->mCreateTime; } } LLSDSerialize::toPrettyXML(data, ostr); } BOOL LLCacheName::getName(const LLUUID& id, std::string& first, std::string& last) { if(id.isNull()) { first = CN_NOBODY; last.clear(); return FALSE; } LLCacheNameEntry* entry = get_ptr_in_map(impl.mCache, id ); if (entry) { first = entry->mFirstName; last = entry->mLastName; return TRUE; } else { first = CN_WAITING; last.clear(); if (!impl.isRequestPending(id)) { impl.mAskNameQueue.insert(id); } return FALSE; } } BOOL LLCacheName::getFullName(const LLUUID& id, std::string& fullname) { std::string first_name, last_name; BOOL res = getName(id, first_name, last_name); fullname = first_name + " " + last_name; return res; } // *TODO: Deprecate BOOL LLCacheName::getName(const LLUUID& id, char* first, char* last) { std::string first_name, last_name; BOOL res = getName(id, first_name, last_name); strcpy(first, first_name.c_str()); strcpy(last, last_name.c_str()); return res; } BOOL LLCacheName::getGroupName(const LLUUID& id, std::string& group) { if(id.isNull()) { group = CN_NONE; return FALSE; } LLCacheNameEntry* entry = get_ptr_in_map(impl.mCache,id); if (entry && !entry->mGroupName[0]) { // COUNTER-HACK to combat James' HACK in exportFile()... // this group name was loaded from a name cache that did not // bother to save the group name ==> we must ask for it lldebugs << "LLCacheName queuing HACK group request: " << id << llendl; entry = NULL; } if (entry) { group = entry->mGroupName; return TRUE; } else { group = CN_WAITING; if (!impl.isRequestPending(id)) { impl.mAskGroupQueue.insert(id); } return FALSE; } } // *TODO: Deprecate BOOL LLCacheName::getGroupName(const LLUUID& id, char* group) { std::string group_name; BOOL res = getGroupName(id, group_name); strcpy(group, group_name.c_str()); return res; } // TODO: Make the cache name callback take a SINGLE std::string, // not a separate first and last name. void LLCacheName::get(const LLUUID& id, BOOL is_group, LLCacheNameCallback callback, void* user_data) { if(id.isNull()) { callback(id, CN_NOBODY, "", is_group, user_data); } LLCacheNameEntry* entry = get_ptr_in_map(impl.mCache, id ); if (entry) { // id found in map therefore we can call the callback immediately. if (entry->mIsGroup) { callback(id, entry->mGroupName, "", entry->mIsGroup, user_data); } else { callback(id, entry->mFirstName, entry->mLastName, entry->mIsGroup, user_data); } } else { // id not found in map so we must queue the callback call until available. if (!impl.isRequestPending(id)) { if (is_group) { impl.mAskGroupQueue.insert(id); } else { impl.mAskNameQueue.insert(id); } } impl.mReplyQueue.push_back(PendingReply(id, callback, user_data)); } } void LLCacheName::processPending() { const F32 SECS_BETWEEN_PROCESS = 0.1f; if(!impl.mProcessTimer.checkExpirationAndReset(SECS_BETWEEN_PROCESS)) { return; } if(!impl.mUpstreamHost.isOk()) { lldebugs << "LLCacheName::processPending() - bad upstream host." << llendl; return; } impl.processPendingAsks(); impl.processPendingReplies(); } void LLCacheName::deleteEntriesOlderThan(S32 secs) { U32 now = (U32)time(NULL); U32 expire_time = now - secs; for(Cache::iterator iter = impl.mCache.begin(); iter != impl.mCache.end(); ) { Cache::iterator curiter = iter++; LLCacheNameEntry* entry = curiter->second; if (entry->mCreateTime < expire_time) { delete entry; impl.mCache.erase(curiter); } } // These are pending requests that we never heard back from. U32 pending_expire_time = now - PENDING_TIMEOUT_SECS; for(PendingQueue::iterator p_iter = impl.mPendingQueue.begin(); p_iter != impl.mPendingQueue.end(); ) { PendingQueue::iterator p_curitor = p_iter++; if (p_curitor->second < pending_expire_time) { impl.mPendingQueue.erase(p_curitor); } } } void LLCacheName::dump() { for (Cache::iterator iter = impl.mCache.begin(), end = impl.mCache.end(); iter != end; iter++) { LLCacheNameEntry* entry = iter->second; if (entry->mIsGroup) { llinfos << iter->first << " = (group) " << entry->mGroupName << " @ " << entry->mCreateTime << llendl; } else { llinfos << iter->first << " = " << entry->mFirstName << " " << entry->mLastName << " @ " << entry->mCreateTime << llendl; } } } void LLCacheName::dumpStats() { llinfos << "Queue sizes: " << " Cache=" << impl.mCache.size() << " AskName=" << impl.mAskNameQueue.size() << " AskGroup=" << impl.mAskGroupQueue.size() << " Pending=" << impl.mPendingQueue.size() << " Reply=" << impl.mReplyQueue.size() << " Observers=" << impl.mObservers.size() << llendl; } //static LLString LLCacheName::getDefaultName() { return LLString(CN_WAITING); } void LLCacheName::Impl::processPendingAsks() { sendRequest(_PREHASH_UUIDNameRequest, mAskNameQueue); sendRequest(_PREHASH_UUIDGroupNameRequest, mAskGroupQueue); mAskNameQueue.clear(); mAskGroupQueue.clear(); } void LLCacheName::Impl::processPendingReplies() { ReplyQueue::iterator it = mReplyQueue.begin(); ReplyQueue::iterator end = mReplyQueue.end(); // First call all the callbacks, because they might send messages. for(; it != end; ++it) { LLCacheNameEntry* entry = get_ptr_in_map(mCache, it->mID); if(!entry) continue; if (it->mCallback) { if (!entry->mIsGroup) { (it->mCallback)(it->mID, entry->mFirstName, entry->mLastName, FALSE, it->mData); } else { (it->mCallback)(it->mID, entry->mGroupName, "", TRUE, it->mData); } } } // Forward on all replies, if needed. ReplySender sender(mMsg); for (it = mReplyQueue.begin(); it != end; ++it) { LLCacheNameEntry* entry = get_ptr_in_map(mCache, it->mID); if(!entry) continue; if (it->mHost.isOk()) { sender.send(it->mID, *entry, it->mHost); } it->done(); } mReplyQueue.erase( remove_if(mReplyQueue.begin(), mReplyQueue.end(), std::mem_fun_ref(&PendingReply::isDone)), mReplyQueue.end()); } void LLCacheName::Impl::sendRequest( const char* msg_name, const AskQueue& queue) { if(queue.empty()) { return; } bool start_new_message = true; AskQueue::const_iterator it = queue.begin(); AskQueue::const_iterator end = queue.end(); for(; it != end; ++it) { if(start_new_message) { start_new_message = false; mMsg->newMessageFast(msg_name); } mMsg->nextBlockFast(_PREHASH_UUIDNameBlock); mMsg->addUUIDFast(_PREHASH_ID, (*it)); if(mMsg->isSendFullFast(_PREHASH_UUIDNameBlock)) { start_new_message = true; mMsg->sendReliable(mUpstreamHost); } } if(!start_new_message) { mMsg->sendReliable(mUpstreamHost); } } void LLCacheName::Impl::notifyObservers(const LLUUID& id, const char* first, const char* last, BOOL is_group) { for (Observers::const_iterator i = mObservers.begin(), end = mObservers.end(); i != end; ++i) { (**i)(id, first, last, is_group, NULL); } } bool LLCacheName::Impl::isRequestPending(const LLUUID& id) { U32 now = (U32)time(NULL); U32 expire_time = now - PENDING_TIMEOUT_SECS; PendingQueue::iterator iter = mPendingQueue.find(id); if (iter == mPendingQueue.end() || (iter->second < expire_time) ) { mPendingQueue[id] = now; return false; } return true; } void LLCacheName::Impl::processUUIDRequest(LLMessageSystem* msg, bool isGroup) { // You should only get this message if the cache is at the simulator // level, hence having an upstream provider. if (!mUpstreamHost.isOk()) { llwarns << "LLCacheName - got UUID name/group request, but no upstream provider!" << llendl; return; } LLHost fromHost = msg->getSender(); ReplySender sender(msg); S32 count = msg->getNumberOfBlocksFast(_PREHASH_UUIDNameBlock); for(S32 i = 0; i < count; ++i) { LLUUID id; msg->getUUIDFast(_PREHASH_UUIDNameBlock, _PREHASH_ID, id, i); LLCacheNameEntry* entry = get_ptr_in_map(mCache, id); if(entry) { if (isGroup != entry->mIsGroup) { llwarns << "LLCacheName - Asked for " << (isGroup ? "group" : "user") << " name, " << "but found " << (entry->mIsGroup ? "group" : "user") << ": " << id << llendl; } else { // ...it's in the cache, so send it as the reply sender.send(id, *entry, fromHost); } } else { if (!isRequestPending(id)) { if (isGroup) { mAskGroupQueue.insert(id); } else { mAskNameQueue.insert(id); } } mReplyQueue.push_back(PendingReply(id, fromHost)); } } } void LLCacheName::Impl::processUUIDReply(LLMessageSystem* msg, bool isGroup) { S32 count = msg->getNumberOfBlocksFast(_PREHASH_UUIDNameBlock); for(S32 i = 0; i < count; ++i) { LLUUID id; msg->getUUIDFast(_PREHASH_UUIDNameBlock, _PREHASH_ID, id, i); LLCacheNameEntry* entry = get_ptr_in_map(mCache, id); if (!entry) { entry = new LLCacheNameEntry; mCache[id] = entry; } mPendingQueue.erase(id); entry->mIsGroup = isGroup; entry->mCreateTime = (U32)time(NULL); if (!isGroup) { msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_FirstName, DB_FIRST_NAME_BUF_SIZE, entry->mFirstName, i); msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_LastName, DB_LAST_NAME_BUF_SIZE, entry->mLastName, i); } else { msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_GroupName, DB_GROUP_NAME_BUF_SIZE, entry->mGroupName, i); } if (!isGroup) { notifyObservers(id, entry->mFirstName, entry->mLastName, FALSE); } else { notifyObservers(id, entry->mGroupName, "", TRUE); } } } // static call back functions void LLCacheName::Impl::handleUUIDNameReply(LLMessageSystem* msg, void** userData) { ((LLCacheName::Impl*)userData)->processUUIDReply(msg, false); } void LLCacheName::Impl::handleUUIDNameRequest(LLMessageSystem* msg, void** userData) { ((LLCacheName::Impl*)userData)->processUUIDRequest(msg, false); } void LLCacheName::Impl::handleUUIDGroupNameRequest(LLMessageSystem* msg, void** userData) { ((LLCacheName::Impl*)userData)->processUUIDRequest(msg, true); } void LLCacheName::Impl::handleUUIDGroupNameReply(LLMessageSystem* msg, void** userData) { ((LLCacheName::Impl*)userData)->processUUIDReply(msg, true); }