Second Life viewer sources 1.19.1.0

1 files changed, 134 insertions, 60 deletions

diff --git a/linden/indra/llmessage/llcachename.cpp b/linden/indra/llmessage/llcachename.cpp
index fb6ca5b..6075958 100644
--- a/linden/indra/llmessage/llcachename.cpp
+++ b/linden/indra/llmessage/llcachename.cpp
@@ -34,19 +34,26 @@
 #include "llcachename.h"
 
 // linden library includes
-#include "message.h"
-#include "llrand.h"
 #include "lldbstrings.h"
 #include "llframetimer.h"
 #include "llhost.h"
+#include "llrand.h"
+#include "llsdserialize.h"
 #include "lluuid.h"
+#include "message.h"
 
 // Constants
 const char* CN_WAITING = "(waiting)";
 const char* CN_NOBODY = "(nobody)";
 const char* CN_NONE = "(none)";
-const char* CN_HIPPOS = "(hippos)";
-const F32 HIPPO_PROBABILITY = 0.01f;
+
+// 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
@@ -392,73 +399,123 @@ void LLCacheName::importFile(FILE* fp)
         llinfos << "LLCacheName loaded " << count << " names" << llendl;
 }
 
-
-void LLCacheName::exportFile(FILE* fp)
+bool LLCacheName::importFile(std::istream& istr)
 {
-        fprintf(fp, "version\t%d\n", CN_FILE_VERSION);
+        LLSD data;
+        if(LLSDSerialize::fromXML(data, istr) < 1)
+                return false;
 
-        for (Cache::iterator iter = impl.mCache.begin(),
-                         end = impl.mCache.end();
-                 iter != end; iter++)
+        // 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)
         {
-                LLCacheNameEntry* entry = iter->second;
-                // Only write entries for which we have valid data.
-                // HACK: Only write agent names.  This makes the reader easier.
-                if (   entry->mFirstName[0]
-                        && entry->mLastName[0])
-                {
-                        LLUUID id = iter->first;
+                LLUUID id((*iter).first);
+                LLSD agent = (*iter).second;
+                U32 ctime = (U32)agent[CTIME].asInteger();
+                if(ctime < delete_before_time) continue;
 
-                        // Trivial XOR encoding
-                        S32 i;
-                        for (i = 0; i < UUID_BYTES; i++)
-                        {
-                                id.mData[i] ^= 0x33;
-                        }
+                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;
 
-                        char id_string[UUID_STR_SIZE]; /*Flawfinder:ignore*/
-                        id.toString(id_string);
+        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;
 
-                        // ...not a group name
-                        fprintf(fp, "%s\t%u\t%s\t%s\n", 
-                                        id_string, 
-                                        entry->mCreateTime,
-                                        entry->mFirstName, 
-                                        entry->mLastName);
+                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, char* first, char* last)
+BOOL LLCacheName::getName(const LLUUID& id, std::string& first, std::string& last)
 {
         if(id.isNull())
         {
-                // The function signature needs to change to pass in the
-                // length of first and last.
-                strcpy(first, CN_NOBODY);       /*Flawfinder: ignore*/
-                last[0] = '\0';
+                first = CN_NOBODY;
+                last.clear();
                 return FALSE;
         }
 
         LLCacheNameEntry* entry = get_ptr_in_map(impl.mCache, id );
         if (entry)
         {
-                // The function signature needs to change to pass in the
-                // length of first and last.
-                strcpy(first, entry->mFirstName);       /*Flawfinder: ignore*/
-                strcpy(last,  entry->mLastName);        /*Flawfinder: ignore*/
+                first = entry->mFirstName;
+                last =  entry->mLastName;
                 return TRUE;
         }
         else
         {
-                //The function signature needs to change to pass in the
-                //length of first and last.
-                strcpy(first,(ll_frand() < HIPPO_PROBABILITY)
-                                                ? CN_HIPPOS 
-                                                : CN_WAITING);
-                strcpy(last, "");       /*Flawfinder: ignore*/
-
+                first = CN_WAITING;
+                last.clear();
                 if (!impl.isRequestPending(id))
                 {
                         impl.mAskNameQueue.insert(id);
@@ -468,15 +525,29 @@ BOOL LLCacheName::getName(const LLUUID& id, char* first, char* last)
 
 }
 
+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, char* group)
+BOOL LLCacheName::getGroupName(const LLUUID& id, std::string& group)
 {
         if(id.isNull())
         {
-                // The function signature needs to change to pass in the
-                // length of first and last.
-                strcpy(group, CN_NONE); /*Flawfinder: ignore*/
+                group = CN_NONE;
                 return FALSE;
         }
 
@@ -492,16 +563,12 @@ BOOL LLCacheName::getGroupName(const LLUUID& id, char* group)
 
         if (entry)
         {
-                // The function signature needs to change to pass in the length
-                // of group.
-                strcpy(group, entry->mGroupName);       /*Flawfinder: ignore*/
+                group = entry->mGroupName;
                 return TRUE;
         }
         else 
         {
-                // The function signature needs to change to pass in the length
-                // of first and last.
-                strcpy(group, CN_WAITING);      /*Flawfinder: ignore*/
+                group = CN_WAITING;
                 if (!impl.isRequestPending(id))
                 {
                         impl.mAskGroupQueue.insert(id);
@@ -510,6 +577,16 @@ BOOL LLCacheName::getGroupName(const LLUUID& id, char* group)
         }
 }
 
+// *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)
@@ -884,6 +961,3 @@ void LLCacheName::Impl::handleUUIDGroupNameReply(LLMessageSystem* msg, void** us
         ((LLCacheName::Impl*)userData)->processUUIDReply(msg, true);
 }
 
-
-
-