Initial update to OpenSim 0.8.2.1 source code.

3 files changed, 510 insertions, 203 deletions

diff --git a/OpenSim/Region/CoreModules/Framework/UserManagement/HGUserManagementModule.cs b/OpenSim/Region/CoreModules/Framework/UserManagement/HGUserManagementModule.cs
index 4ef57fe..7b89c2c 100644
--- a/OpenSim/Region/CoreModules/Framework/UserManagement/HGUserManagementModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/UserManagement/HGUserManagementModule.cs
@@ -50,16 +50,15 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-
         #region ISharedRegionModule
 
         public new void Initialise(IConfigSource config)
         {
-            string umanmod = config.Configs["Modules"].GetString("UserManagementModule", base.Name);
+            string umanmod = config.Configs["Modules"].GetString("UserManagementModule", null);
             if (umanmod == Name)
             {
                 m_Enabled = true;
-                RegisterConsoleCmds();
+                Init();
                 m_log.DebugFormat("[USER MANAGEMENT MODULE]: {0} is enabled", Name);
             }
         }
@@ -71,7 +70,7 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
         #endregion ISharedRegionModule
 
-        protected override void AddAdditionalUsers(UUID avatarID, string query, List<UserData> users)
+        protected override void AddAdditionalUsers(string query, List<UserData> users)
         {
             if (query.Contains("@"))  // First.Last@foo.com, maybe?
             {
@@ -131,7 +130,17 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
                         }
 
                         UserAgentServiceConnector uasConn = new UserAgentServiceConnector(uriStr);
-                        UUID userID = uasConn.GetUUID(names[0], names[1]);
+                        
+                        UUID userID = UUID.Zero;
+                        try
+                        {
+                            userID = uasConn.GetUUID(names[0], names[1]);
+                        }
+                        catch (Exception e)
+                        {
+                            m_log.Debug("[USER MANAGEMENT MODULE]: GetUUID call failed ", e);
+                        }
+                        
                         if (!userID.Equals(UUID.Zero))
                         {
                             UserData ud = new UserData();
diff --git a/OpenSim/Region/CoreModules/Framework/UserManagement/Tests/HGUserManagementModuleTests.cs b/OpenSim/Region/CoreModules/Framework/UserManagement/Tests/HGUserManagementModuleTests.cs
new file mode 100644
index 0000000..4e3b7e5
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/UserManagement/Tests/HGUserManagementModuleTests.cs
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.Framework.UserManagement;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.CoreModules.Framework.UserManagement.Tests
+{
+    [TestFixture]
+    public class HGUserManagementModuleTests : OpenSimTestCase
+    {    
+        /// <summary>
+        /// Test that a new HG agent (i.e. one without a user account) has their name cached in the UMM upon creation.
+        /// </summary>
+        [Test]
+        public void TestCachedUserNameForNewAgent()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            HGUserManagementModule hgumm = new HGUserManagementModule();
+            UUID userId = TestHelpers.ParseStem("11");
+            string firstName = "Fred";
+            string lastName = "Astaire";
+            string homeUri = "example.com";
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Modules");
+            config.Configs["Modules"].Set("UserManagementModule", hgumm.Name);
+
+            SceneHelpers sceneHelpers = new SceneHelpers();
+            TestScene scene = sceneHelpers.SetupScene();
+            SceneHelpers.SetupSceneModules(scene, config, hgumm);
+
+            AgentCircuitData acd = SceneHelpers.GenerateAgentData(userId);
+            acd.firstname = firstName;
+            acd.lastname = lastName;
+            acd.ServiceURLs["HomeURI"] = "http://" + homeUri;
+
+            SceneHelpers.AddScenePresence(scene, acd);
+
+            string name = hgumm.GetUserName(userId);
+            Assert.That(name, Is.EqualTo(string.Format("{0}.{1} @{2}", firstName, lastName, homeUri)));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs b/OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs
index 77e8b00..7ecbd26 100644
--- a/OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs
@@ -28,9 +28,11 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
+using System.Threading;
 
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Region.ClientStack.LindenUDP;
 using OpenSim.Region.Framework;
 using OpenSim.Region.Framework.Interfaces;
@@ -44,28 +46,24 @@ using log4net;
 using Nini.Config;
 using Mono.Addins;
 
+using DirFindFlags = OpenMetaverse.DirectoryManager.DirFindFlags;
+
 namespace OpenSim.Region.CoreModules.Framework.UserManagement
 {
-    public class UserData
-    {
-        public UUID Id { get; set; }
-        public string FirstName { get; set; }
-        public string LastName { get; set; }
-        public string HomeURL { get; set; }
-        public Dictionary<string, object> ServerURLs { get; set; }
-    }
-
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "UserManagementModule")]
-    public class UserManagementModule : ISharedRegionModule, IUserManagement
+    public class UserManagementModule : ISharedRegionModule, IUserManagement, IPeople
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         protected bool m_Enabled;
         protected List<Scene> m_Scenes = new List<Scene>();
 
+        protected IServiceThrottleModule m_ServiceThrottle;
         // The cache
         protected Dictionary<UUID, UserData> m_UserCache = new Dictionary<UUID, UserData>();
 
+        protected bool m_DisplayChangingHomeURI = false;
+
         #region ISharedRegionModule
 
         public void Initialise(IConfigSource config)
@@ -74,9 +72,20 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             if (umanmod == Name)
             {
                 m_Enabled = true;
-                RegisterConsoleCmds();
+                Init();
                 m_log.DebugFormat("[USER MANAGEMENT MODULE]: {0} is enabled", Name);
             }
+
+            if(!m_Enabled)
+            {
+                return;
+            }
+
+            IConfig userManagementConfig = config.Configs["UserManagement"];
+            if (userManagementConfig == null)
+                return;
+
+            m_DisplayChangingHomeURI = userManagementConfig.GetBoolean("DisplayChangingHomeURI", false);
         }
 
         public bool IsSharedModule
@@ -98,9 +107,13 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
         {
             if (m_Enabled)
             {
-                m_Scenes.Add(scene);
+                lock (m_Scenes)
+                {
+                    m_Scenes.Add(scene);
+                }
 
                 scene.RegisterModuleInterface<IUserManagement>(this);
+                scene.RegisterModuleInterface<IPeople>(this);
                 scene.EventManager.OnNewClient += new EventManager.OnNewClientDelegate(EventManager_OnNewClient);
                 scene.EventManager.OnPrimsLoaded += new EventManager.PrimsLoaded(EventManager_OnPrimsLoaded);
             }
@@ -111,12 +124,17 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             if (m_Enabled)
             {
                 scene.UnregisterModuleInterface<IUserManagement>(this);
-                m_Scenes.Remove(scene);
+                lock (m_Scenes)
+                {
+                    m_Scenes.Remove(scene);
+                }
             }
         }
 
         public void RegionLoaded(Scene s)
         {
+            if (m_Enabled && m_ServiceThrottle == null)
+                m_ServiceThrottle = s.RequestModuleInterface<IServiceThrottleModule>();
         }
 
         public void PostInitialise()
@@ -125,7 +143,10 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
         public void Close()
         {
-            m_Scenes.Clear();
+            lock (m_Scenes)
+            {
+                m_Scenes.Clear();
+            }
 
             lock (m_UserCache)
                 m_UserCache.Clear();
@@ -133,7 +154,7 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
         #endregion ISharedRegionModule
 
- 
+
         #region Event Handlers
 
         void EventManager_OnPrimsLoaded(Scene s)
@@ -143,7 +164,6 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             s.ForEachSOG(delegate(SceneObjectGroup sog) { CacheCreators(sog); });
         }
 
-
         void EventManager_OnNewClient(IClientAPI client)
         {
             client.OnConnectionClosed += new Action<IClientAPI>(HandleConnectionClosed);
@@ -157,21 +177,52 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             client.OnAvatarPickerRequest -= new AvatarPickerRequest(HandleAvatarPickerRequest);
         }
 
-        void HandleUUIDNameRequest(UUID uuid, IClientAPI remote_client)
+        void HandleUUIDNameRequest(UUID uuid, IClientAPI client)
         {
+//            m_log.DebugFormat(
+//                "[USER MANAGEMENT MODULE]: Handling request for name binding of UUID {0} from {1}",
+//                uuid, remote_client.Name);
+
             if (m_Scenes[0].LibraryService != null && (m_Scenes[0].LibraryService.LibraryRootFolder.Owner == uuid))
             {
-                remote_client.SendNameReply(uuid, "Mr", "OpenSim");
+                client.SendNameReply(uuid, "Mr", "OpenSim");
             }
             else
             {
-                string[] names = GetUserNames(uuid);
-                if (names.Length == 2)
+                UserData user;
+                /* bypass that continuation here when entry is already available */
+                lock (m_UserCache)
                 {
-                    //m_log.DebugFormat("[XXX] HandleUUIDNameRequest {0} is {1} {2}", uuid, names[0], names[1]);
-                    remote_client.SendNameReply(uuid, names[0], names[1]);
+                    if (m_UserCache.TryGetValue(uuid, out user))
+                    {
+                        if (!user.IsUnknownUser && user.HasGridUserTried)
+                        {
+                            client.SendNameReply(uuid, user.FirstName, user.LastName);
+                            return;
+                        }
+                    }
                 }
 
+                // Not found in cache, queue continuation
+                m_ServiceThrottle.Enqueue("name", uuid.ToString(),  delegate
+                {
+                    //m_log.DebugFormat("[YYY]: Name request {0}", uuid);
+
+                    // As least upto September 2013, clients permanently cache UUID -> Name bindings.  Some clients
+                    // appear to clear this when the user asks it to clear the cache, but others may not.
+                    //
+                    // So to avoid clients
+                    // (particularly Hypergrid clients) permanently binding "Unknown User" to a given UUID, we will
+                    // instead drop the request entirely.
+                    if (GetUser(uuid, out user))
+                    {
+                        client.SendNameReply(uuid, user.FirstName, user.LastName);
+                    }
+//                    else
+//                        m_log.DebugFormat(
+//                            "[USER MANAGEMENT MODULE]: No bound name for {0} found, ignoring request from {1}",
+//                            uuid, client.Name);
+                });
             }
         }
 
@@ -181,29 +232,7 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
             m_log.DebugFormat("[USER MANAGEMENT MODULE]: HandleAvatarPickerRequest for {0}", query);
 
-            // searhc the user accounts service
-            List<UserAccount> accs = m_Scenes[0].UserAccountService.GetUserAccounts(m_Scenes[0].RegionInfo.ScopeID, query);
-
-            List<UserData> users = new List<UserData>();
-            if (accs != null)
-            {
-                foreach (UserAccount acc in accs)
-                {
-                    UserData ud = new UserData();
-                    ud.FirstName = acc.FirstName;
-                    ud.LastName = acc.LastName;
-                    ud.Id = acc.PrincipalID;
-                    users.Add(ud);
-                }
-            }
-
-            // search the local cache
-            foreach (UserData data in m_UserCache.Values)
-                if (users.Find(delegate(UserData d) { return d.Id == data.Id; }) == null &&
-                    (data.FirstName.StartsWith(query) || data.LastName.StartsWith(query)))
-                    users.Add(data);
-
-            AddAdditionalUsers(avatarID, query, users);
+            List<UserData> users = GetUserData(query, 500, 1);
 
             AvatarPickerReplyPacket replyPacket = (AvatarPickerReplyPacket)PacketPool.Instance.GetPacket(PacketType.AvatarPickerReply);
             // TODO: don't create new blocks if recycling an old packet
@@ -249,60 +278,62 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             client.SendAvatarPickerReply(agent_data, data_args);
         }
 
-        protected virtual void AddAdditionalUsers(UUID avatarID, string query, List<UserData> users)
+        protected virtual void AddAdditionalUsers(string query, List<UserData> users)
         {
         }
 
         #endregion Event Handlers
 
-        private void CacheCreators(SceneObjectGroup sog)
-        {
-            //m_log.DebugFormat("[USER MANAGEMENT MODULE]: processing {0} {1}; {2}", sog.RootPart.Name, sog.RootPart.CreatorData, sog.RootPart.CreatorIdentification);
-            AddUser(sog.RootPart.CreatorID, sog.RootPart.CreatorData);
-
-            foreach (SceneObjectPart sop in sog.Parts)
-            {
-                AddUser(sop.CreatorID, sop.CreatorData);
-                foreach (TaskInventoryItem item in sop.TaskInventory.Values)
-                    AddUser(item.CreatorID, item.CreatorData);
-            }
-        }
+        #region IPeople
 
-        private string[] GetUserNames(UUID uuid)
+        public List<UserData> GetUserData(string query, int page_size, int page_number)
         {
-            string[] returnstring = new string[2];
+            // search the user accounts service
+            List<UserAccount> accs = m_Scenes[0].UserAccountService.GetUserAccounts(m_Scenes[0].RegionInfo.ScopeID, query);
 
-            lock (m_UserCache)
+            List<UserData> users = new List<UserData>();
+            if (accs != null)
             {
-                if (m_UserCache.ContainsKey(uuid))
+                foreach (UserAccount acc in accs)
                 {
-                    returnstring[0] = m_UserCache[uuid].FirstName;
-                    returnstring[1] = m_UserCache[uuid].LastName;
-                    return returnstring;
+                    UserData ud = new UserData();
+                    ud.FirstName = acc.FirstName;
+                    ud.LastName = acc.LastName;
+                    ud.Id = acc.PrincipalID;
+                    ud.HasGridUserTried = true;
+                    ud.IsUnknownUser = false;
+                    users.Add(ud);
                 }
             }
 
-            UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, uuid);
-
-            if (account != null)
+            // search the local cache
+            foreach (UserData data in m_UserCache.Values)
             {
-                returnstring[0] = account.FirstName;
-                returnstring[1] = account.LastName;
+                if (data.Id != UUID.Zero && !data.IsUnknownUser &&
+                    users.Find(delegate(UserData d) { return d.Id == data.Id; }) == null &&
+                    (data.FirstName.ToLower().StartsWith(query.ToLower()) || data.LastName.ToLower().StartsWith(query.ToLower())))
+                    users.Add(data);
+            }
 
-                UserData user = new UserData();
-                user.FirstName = account.FirstName;
-                user.LastName = account.LastName;
+            AddAdditionalUsers(query, users);
 
-                lock (m_UserCache)
-                    m_UserCache[uuid] = user;
-            }
-            else
+            return users;
+
+        }
+
+        #endregion IPeople
+
+        private void CacheCreators(SceneObjectGroup sog)
+        {
+            //m_log.DebugFormat("[USER MANAGEMENT MODULE]: processing {0} {1}; {2}", sog.RootPart.Name, sog.RootPart.CreatorData, sog.RootPart.CreatorIdentification);
+            AddUser(sog.RootPart.CreatorID, sog.RootPart.CreatorData);
+
+            foreach (SceneObjectPart sop in sog.Parts)
             {
-                returnstring[0] = "Unknown";
-                returnstring[1] = "User";
+                AddUser(sop.CreatorID, sop.CreatorData);
+                foreach (TaskInventoryItem item in sop.TaskInventory.Values)
+                    AddUser(item.CreatorID, item.CreatorData);
             }
-
-            return returnstring;
         }
 
         #region IUserManagement
@@ -338,55 +369,56 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
         public string GetUserName(UUID uuid)
         {
-            string[] names = GetUserNames(uuid);
-            if (names.Length == 2)
-            {
-                string firstname = names[0];
-                string lastname = names[1];
-
-                return firstname + " " + lastname;
-
-            }
-            return "(hippos)";
+            UserData user;
+            GetUser(uuid, out user);
+            return user.FirstName + " " + user.LastName;
         }
 
         public string GetUserHomeURL(UUID userID)
         {
-            lock (m_UserCache)
+            UserData user;
+            if(GetUser(userID, out user))
             {
-                if (m_UserCache.ContainsKey(userID))
-                    return m_UserCache[userID].HomeURL;
+                return user.HomeURL;
             }
-
             return string.Empty;
         }
 
         public string GetUserServerURL(UUID userID, string serverType)
         {
             UserData userdata;
-            lock (m_UserCache)
-                m_UserCache.TryGetValue(userID, out userdata);
+            if(!GetUser(userID, out userdata))
+            {
+                return string.Empty;
+            }
+
+            if (userdata.ServerURLs != null && userdata.ServerURLs.ContainsKey(serverType) && userdata.ServerURLs[serverType] != null)
+            {
+                return userdata.ServerURLs[serverType].ToString();
+            }
 
-            if (userdata != null)
+            if (!string.IsNullOrEmpty(userdata.HomeURL))
             {
 //                m_log.DebugFormat("[USER MANAGEMENT MODULE]: Requested url type {0} for {1}", serverType, userID);
 
-                if (userdata.ServerURLs != null && userdata.ServerURLs.ContainsKey(serverType) && userdata.ServerURLs[serverType] != null)
+                UserAgentServiceConnector uConn = new UserAgentServiceConnector(userdata.HomeURL);
+                try
                 {
-                    return userdata.ServerURLs[serverType].ToString();
+                    userdata.ServerURLs = uConn.GetServerURLs(userID);
                 }
-
-                if (userdata.HomeURL != null && userdata.HomeURL != string.Empty)
+                catch(System.Net.WebException e)
                 {
-                    //m_log.DebugFormat(
-                    //    "[USER MANAGEMENT MODULE]: Did not find url type {0} so requesting urls from '{1}' for {2}",
-                    //    serverType, userdata.HomeURL, userID);
-
-                    UserAgentServiceConnector uConn = new UserAgentServiceConnector(userdata.HomeURL);
-                    userdata.ServerURLs = uConn.GetServerURLs(userID);
-                    if (userdata.ServerURLs != null && userdata.ServerURLs.ContainsKey(serverType) && userdata.ServerURLs[serverType] != null)
-                        return userdata.ServerURLs[serverType].ToString();
+                    m_log.DebugFormat("[USER MANAGEMENT MODULE]: GetServerURLs call failed {0}", e.Message);
+                    userdata.ServerURLs = new Dictionary<string, object>();
                 }
+                catch (Exception e)
+                {
+                    m_log.Debug("[USER MANAGEMENT MODULE]: GetServerURLs call failed ", e);
+                    userdata.ServerURLs = new Dictionary<string, object>();
+                }
+
+                if (userdata.ServerURLs != null && userdata.ServerURLs.ContainsKey(serverType) && userdata.ServerURLs[serverType] != null)
+                    return userdata.ServerURLs[serverType].ToString();
             }
 
             return string.Empty;
@@ -394,13 +426,15 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
         public string GetUserUUI(UUID userID)
         {
-            UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, userID);
-            if (account != null)
-                return userID.ToString();
+            string uui;
+            GetUserUUI(userID, out uui);
+            return uui;
+        }
 
+        public bool GetUserUUI(UUID userID, out string uui)
+        {
             UserData ud;
-            lock (m_UserCache)
-                m_UserCache.TryGetValue(userID, out ud);
+            bool result = GetUser(userID, out ud);
 
             if (ud != null)
             {
@@ -414,121 +448,251 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
                         first = parts[0];
                         last = parts[1];
                     }
-                    return userID + ";" + homeURL + ";" + first + " " + last;
+                    uui = userID + ";" + homeURL + ";" + first + " " + last;
                 }
             }
 
-            return userID.ToString();
+            uui = userID.ToString();
+            return result;
         }
 
-        public void AddUser(UUID uuid, string first, string last)
+        #region Cache Management
+        public bool GetUser(UUID uuid, out UserData userdata)
         {
             lock (m_UserCache)
             {
-                if (m_UserCache.ContainsKey(uuid))
-                    return;
+                if (m_UserCache.TryGetValue(uuid, out userdata))
+                {
+                    if (userdata.HasGridUserTried)
+                    {
+                        return true;
+                    }
+                }
+                else
+                {
+                    userdata = new UserData();
+                    userdata.HasGridUserTried = false;
+                    userdata.Id = uuid;
+                    userdata.FirstName = "Unknown";
+                    userdata.LastName = "UserUMMAU42";
+                    userdata.HomeURL = string.Empty;
+                    userdata.IsUnknownUser = true;
+                    userdata.HasGridUserTried = false;
+                }
+            }
+
+            /* BEGIN: do not wrap this code in any lock here
+             * There are HTTP calls in here.
+             */
+            if (!userdata.HasGridUserTried)
+            {
+                /* rewrite here */
+                UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, uuid);
+                if (account != null)
+                {
+                    userdata.FirstName = account.FirstName;
+                    userdata.LastName = account.LastName;
+                    userdata.HomeURL = string.Empty;
+                    userdata.IsUnknownUser = false;
+                    userdata.HasGridUserTried = true;
+                }
             }
 
-            UserData user = new UserData();
-            user.Id = uuid;
-            user.FirstName = first;
-            user.LastName = last;
+            if (!userdata.HasGridUserTried)
+            {
+                GridUserInfo uInfo = null;
+                if (null != m_Scenes[0].GridUserService)
+                {
+                    uInfo = m_Scenes[0].GridUserService.GetGridUserInfo(uuid.ToString());
+                }
+                if (uInfo != null)
+                {
+                    string url, first, last, tmp;
+                    UUID u;
+                    if(uInfo.UserID.Length <= 36)
+                    {
+                        /* not a UUI */
+                    }
+                    else if (Util.ParseUniversalUserIdentifier(uInfo.UserID, out u, out url, out first, out last, out tmp))
+                    {
+                        if (url != string.Empty)
+                        {
+                            userdata.FirstName = first.Replace(" ", ".") + "." + last.Replace(" ", ".");
+                            userdata.HomeURL = url;
+                            try
+                            {
+                                userdata.LastName = "@" + new Uri(url).Authority;
+                                userdata.IsUnknownUser = false;
+                            }
+                            catch
+                            {
+                                userdata.LastName = "@unknown";
+                            }
+                            userdata.HasGridUserTried = true;
+                        }
+                    }
+                    else
+                        m_log.DebugFormat("[USER MANAGEMENT MODULE]: Unable to parse UUI {0}", uInfo.UserID);
+                }
+            }
+            /* END: do not wrap this code in any lock here */
 
-            AddUserInternal(user);
+            lock (m_UserCache)
+            {
+                m_UserCache[uuid] = userdata;
+            }
+            return !userdata.IsUnknownUser;
         }
 
-        public void AddUser(UUID uuid, string first, string last, string homeURL)
+        public void AddUser(UUID uuid, string first, string last)
         {
-            //m_log.DebugFormat("[USER MANAGEMENT MODULE]: Adding user with id {0}, first {1}, last {2}, url {3}", uuid, first, last, homeURL);
-            if (homeURL == string.Empty)
-                return;
-
-            AddUser(uuid, homeURL + ";" + first + " " + last);
+            lock(m_UserCache)
+            {
+                if(!m_UserCache.ContainsKey(uuid))
+                {
+                    UserData user = new UserData();
+                    user.Id = uuid;
+                    user.FirstName = first;
+                    user.LastName = last;
+                    user.IsUnknownUser = false;
+                    user.HasGridUserTried = false;
+                    m_UserCache.Add(uuid, user);
+                }
+            }
         }
 
-        public void AddUser (UUID id, string creatorData)
+        public void AddUser(UUID uuid, string first, string last, string homeURL)
         {
-            //m_log.DebugFormat("[USER MANAGEMENT MODULE]: Adding user with id {0}, creatorData {1}", id, creatorData);
+            //m_log.DebugFormat("[USER MANAGEMENT MODULE]: Adding user with id {0}, first {1}, last {2}, url {3}", uuid, first, last, homeURL);
 
             UserData oldUser;
-            //lock the whole block - prevent concurrent update
             lock (m_UserCache)
             {
-                m_UserCache.TryGetValue (id, out oldUser);
-                if (oldUser != null)
+                if (m_UserCache.TryGetValue(uuid, out oldUser))
                 {
-                    if (creatorData == null || creatorData == String.Empty)
+                    if (!oldUser.IsUnknownUser)
                     {
-                        //ignore updates without creator data
+                        if (homeURL != oldUser.HomeURL && m_DisplayChangingHomeURI)
+                        {
+                            m_log.DebugFormat("[USER MANAGEMENT MODULE]: Different HomeURI for {0} {1} ({2}): {3} and {4}",
+                                first, last, uuid.ToString(), homeURL, oldUser.HomeURL);
+                        }
+                        /* no update needed */
                         return;
                     }
-                    //try update unknown users
-                    //and creator's home URL's
-                    if ((oldUser.FirstName == "Unknown" && !creatorData.Contains ("Unknown")) || (oldUser.HomeURL != null && !creatorData.StartsWith (oldUser.HomeURL)))
+                }
+                else if(!m_UserCache.ContainsKey(uuid))
+                {
+                    oldUser = new UserData();
+                    oldUser.HasGridUserTried = false;
+                    oldUser.IsUnknownUser = false;
+                    if (homeURL != string.Empty)
                     {
-                        m_UserCache.Remove (id);
-//                      m_log.DebugFormat("[USER MANAGEMENT MODULE]: Re-adding user with id {0}, creatorData [{1}] and old HomeURL {2}", id, creatorData,oldUser.HomeURL);
+                        oldUser.FirstName = first.Replace(" ", ".") + "." + last.Replace(" ", ".");
+                        try
+                        {
+                            oldUser.LastName = "@" + new Uri(homeURL).Authority;
+                            oldUser.IsUnknownUser = false;
+                        }
+                        catch
+                        {
+                            oldUser.LastName = "@unknown";
+                        }
                     }
                     else
                     {
-                        //we have already a valid user within the cache
-                        return;
+                        oldUser.FirstName = first;
+                        oldUser.LastName = last;
                     }
+                    oldUser.HomeURL = homeURL;
+                    oldUser.Id = uuid;
+                    m_UserCache.Add(uuid, oldUser);
                 }
+            }
+        }
 
-                UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount (m_Scenes [0].RegionInfo.ScopeID, id);
+        public void AddUser(UUID id, string creatorData)
+        {
+            // m_log.InfoFormat("[USER MANAGEMENT MODULE]: Adding user with id {0}, creatorData {1}", id, creatorData);
 
-                if (account != null)
+            if(string.IsNullOrEmpty(creatorData))
+            {
+                AddUser(id, string.Empty, string.Empty, string.Empty);
+            }
+            else
+            {
+                string homeURL;
+                string firstname = string.Empty;
+                string lastname = string.Empty;
+
+                //creatorData = <endpoint>;<name>
+
+                string[] parts = creatorData.Split(';');
+                if(parts.Length > 1)
                 {
-                    AddUser (id, account.FirstName, account.LastName);
+                    string[] nameparts = parts[1].Split(' ');
+                    firstname = nameparts[0];
+                    for(int xi = 1; xi < nameparts.Length; ++xi)
+                    {
+                        if(xi != 1)
+                        {
+                            lastname += " ";
+                        }
+                        lastname += nameparts[xi];
+                    }
                 }
                 else
                 {
-                    UserData user = new UserData ();
-                    user.Id = id;
-
-                    if (creatorData != null && creatorData != string.Empty)
+                    firstname = "Unknown";
+                    lastname = "UserUMMAU5";
+                }
+                if (parts.Length >= 1)
+                {
+                    homeURL = parts[0];
+                    if(Uri.IsWellFormedUriString(homeURL, UriKind.Absolute))
+                    {
+                        AddUser(id, firstname, lastname, homeURL);
+                    }
+                    else
                     {
-                        //creatorData = <endpoint>;<name>
+                        m_log.DebugFormat("[SCENE]: Unable to parse Uri {0} for CreatorID {1}", parts[0], creatorData);
 
-                        string[] parts = creatorData.Split (';');
-                        if (parts.Length >= 1)
+                        lock (m_UserCache)
                         {
-                            user.HomeURL = parts [0];
-                            try
-                            {
-                                Uri uri = new Uri (parts [0]);
-                                user.LastName = "@" + uri.Authority;
-                            }
-                            catch (UriFormatException)
+                            if(!m_UserCache.ContainsKey(id))
                             {
-                                m_log.DebugFormat ("[SCENE]: Unable to parse Uri {0}", parts [0]);
-                                user.LastName = "@unknown";
+                                UserData newUser = new UserData();
+                                newUser.Id = id;
+                                newUser.FirstName = firstname + "." + lastname.Replace(' ', '.');
+                                newUser.LastName = "@unknown";
+                                newUser.HomeURL = string.Empty;
+                                newUser.HasGridUserTried = false;
+                                newUser.IsUnknownUser = true; /* we mark those users as Unknown user so a re-retrieve may be activated */
+                                m_UserCache.Add(id, newUser);
                             }
                         }
-                        if (parts.Length >= 2)
-                            user.FirstName = parts [1].Replace (' ', '.');
                     }
-                    else
+                }
+                else
+                {
+                    lock(m_UserCache)
                     {
-                        user.FirstName = "Unknown";
-                        user.LastName = "User";
+                        if(!m_UserCache.ContainsKey(id))
+                        {
+                            UserData newUser = new UserData();
+                            newUser.Id = id;
+                            newUser.FirstName = "Unknown";
+                            newUser.LastName = "UserUMMAU4";
+                            newUser.HomeURL = string.Empty;
+                            newUser.IsUnknownUser = true;
+                            newUser.HasGridUserTried = false;
+                            m_UserCache.Add(id, newUser);
+                        }
                     }
-
-                    AddUserInternal (user);
                 }
             }
         }
-
-        void AddUserInternal(UserData user)
-        {
-            lock (m_UserCache)
-                m_UserCache[user.Id] = user;
-
-            //m_log.DebugFormat(
-            //    "[USER MANAGEMENT MODULE]: Added user {0} {1} {2} {3}",
-            //    user.Id, user.FirstName, user.LastName, user.HomeURL);
-        }
+        #endregion
 
         public bool IsLocalGridUser(UUID uuid)
         {
@@ -541,36 +705,95 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
         #endregion IUserManagement
 
+        protected void Init()
+        {
+            AddUser(UUID.Zero, "Unknown", "User");
+            RegisterConsoleCmds();
+        }
+
         protected void RegisterConsoleCmds()
         {
             MainConsole.Instance.Commands.AddCommand("Users", true,
+                "show name",
+                "show name <uuid>",
+                "Show the bindings between a single user UUID and a user name",
+                String.Empty,
+                HandleShowUser);
+
+            MainConsole.Instance.Commands.AddCommand("Users", true,
                 "show names",
                 "show names",
                 "Show the bindings between user UUIDs and user names",
                 String.Empty,
                 HandleShowUsers);
+
+            MainConsole.Instance.Commands.AddCommand("Users", true,
+                "reset user cache",
+                "reset user cache",
+                "reset user cache to allow changed settings to be applied",
+                String.Empty,
+                HandleResetUserCache);
         }
 
-        private void HandleShowUsers(string module, string[] cmd)
+        private void HandleResetUserCache(string module, string[] cmd)
         {
-            lock (m_UserCache)
+            lock(m_UserCache)
             {
-                if (m_UserCache.Count == 0)
-                {
-                    MainConsole.Instance.Output("No users found");
-                    return;
-                }
-    
-                MainConsole.Instance.Output("UUID                                 User Name");
-                MainConsole.Instance.Output("-----------------------------------------------------------------------------");
-                foreach (KeyValuePair<UUID, UserData> kvp in m_UserCache)
-                {
-                    MainConsole.Instance.Output(String.Format("{0} {1} {2} ({3})",
-                           kvp.Key, kvp.Value.FirstName, kvp.Value.LastName, kvp.Value.HomeURL));
-                }
-    
+                m_UserCache.Clear();
+            }
+        }
+
+        private void HandleShowUser(string module, string[] cmd)
+        {
+            if (cmd.Length < 3)
+            {
+                MainConsole.Instance.OutputFormat("Usage: show name <uuid>");
                 return;
             }
+
+            UUID userId;
+            if (!ConsoleUtil.TryParseConsoleUuid(MainConsole.Instance, cmd[2], out userId))
+                return;
+
+            UserData ud;
+
+            if(!GetUser(userId, out ud))
+            {
+                MainConsole.Instance.OutputFormat("No name known for user with id {0}", userId);
+                return;
+            }
+
+            ConsoleDisplayTable cdt = new ConsoleDisplayTable();
+            cdt.AddColumn("UUID", 36);
+            cdt.AddColumn("Name", 30);
+            cdt.AddColumn("HomeURL", 40);
+            cdt.AddRow(userId, string.Format("{0} {1}", ud.FirstName, ud.LastName), ud.HomeURL);
+
+            MainConsole.Instance.Output(cdt.ToString());
         }
+
+        private void HandleShowUsers(string module, string[] cmd)
+        {
+            ConsoleDisplayTable cdt = new ConsoleDisplayTable();
+            cdt.AddColumn("UUID", 36);
+            cdt.AddColumn("Name", 30);
+            cdt.AddColumn("HomeURL", 40);
+            cdt.AddColumn("Checked", 10);
+
+            Dictionary<UUID, UserData> copyDict;
+            lock(m_UserCache)
+            {
+                copyDict = new Dictionary<UUID, UserData>(m_UserCache);
+            }
+
+            foreach(KeyValuePair<UUID, UserData> kvp in copyDict)
+            {
+                cdt.AddRow(kvp.Key, string.Format("{0} {1}", kvp.Value.FirstName, kvp.Value.LastName), kvp.Value.HomeURL, kvp.Value.HasGridUserTried ? "yes" : "no");
+            }
+
+            MainConsole.Instance.Output(cdt.ToString());
+        }
+
     }
-}
\ No newline at end of file
+
+}