Merge branch 'master' of ssh://opensimulator.org/var/git/opensim

12 files changed, 412 insertions, 112 deletions

diff --git a/OpenSim/Framework/Console/CommandConsole.cs b/OpenSim/Framework/Console/CommandConsole.cs
index 0d6288b..c5d6b78 100644
--- a/OpenSim/Framework/Console/CommandConsole.cs
+++ b/OpenSim/Framework/Console/CommandConsole.cs
@@ -29,6 +29,7 @@ using System;
 using System.Xml;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -40,6 +41,8 @@ namespace OpenSim.Framework.Console
 {
     public class Commands : ICommands
     {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         /// <summary>
         /// Encapsulates a command that can be invoked from the console
         /// </summary>
@@ -76,6 +79,8 @@ namespace OpenSim.Framework.Console
             public List<CommandDelegate> fn;
         }
 
+        public const string GeneralHelpText = "For more information, type 'help <item>' where <item> is one of the following categories:";
+
         /// <value>
         /// Commands organized by keyword in a tree
         /// </value>
@@ -83,6 +88,11 @@ namespace OpenSim.Framework.Console
                 new Dictionary<string, object>();
 
         /// <summary>
+        /// Commands organized by module
+        /// </summary>
+        private Dictionary<string, List<CommandInfo>> m_modulesCommands = new Dictionary<string, List<CommandInfo>>();
+
+        /// <summary>
         /// Get help for the given help string
         /// </summary>
         /// <param name="helpParts">Parsed parts of the help string.  If empty then general help is returned.</param>
@@ -98,8 +108,8 @@ namespace OpenSim.Framework.Console
             // General help
             if (helpParts.Count == 0)
             {
-                help.AddRange(CollectHelp(tree));
-                help.Sort();
+                help.Add(GeneralHelpText);
+                help.AddRange(CollectModulesHelp(tree));
             }
             else
             {
@@ -118,6 +128,13 @@ namespace OpenSim.Framework.Console
         {
             string originalHelpRequest = string.Join(" ", helpParts.ToArray());
             List<string> help = new List<string>();
+
+            // Check modules first to see if we just need to display a list of those commands
+            if (TryCollectModuleHelp(originalHelpRequest, help))
+            {
+                help.Insert(0, GeneralHelpText);
+                return help;
+            }
             
             Dictionary<string, object> dict = tree;
             while (helpParts.Count > 0)
@@ -161,25 +178,63 @@ namespace OpenSim.Framework.Console
             return help;
         }
 
-        private List<string> CollectHelp(Dictionary<string, object> dict)
+        /// <summary>
+        /// Try to collect help for the given module if that module exists.
+        /// </summary>
+        /// <param name="moduleName"></param>
+        /// <param name="helpText">/param>
+        /// <returns>true if there was the module existed, false otherwise.</returns>
+        private bool TryCollectModuleHelp(string moduleName, List<string> helpText)
         {
-            List<string> result = new List<string>();
-
-            foreach (KeyValuePair<string, object> kvp in dict)
+            lock (m_modulesCommands)
             {
-                if (kvp.Value is Dictionary<string, Object>)
+                foreach (string key in m_modulesCommands.Keys)
                 {
-                    result.AddRange(CollectHelp((Dictionary<string, Object>)kvp.Value));
-                }
-                else
-                {
-                    if (((CommandInfo)kvp.Value).long_help != String.Empty)
-                        result.Add(((CommandInfo)kvp.Value).help_text+" - "+
-                                ((CommandInfo)kvp.Value).long_help);
+                    // Allow topic help requests to succeed whether they are upper or lowercase.
+                    if (moduleName.ToLower() == key.ToLower())
+                    {
+                        List<CommandInfo> commands = m_modulesCommands[key];
+                        var ourHelpText = commands.ConvertAll(c => string.Format("{0} - {1}", c.help_text, c.long_help));
+                        ourHelpText.Sort();
+                        helpText.AddRange(ourHelpText);
+
+                        return true;
+                    }
                 }
+
+                return false;
+            }
+        }
+
+        private List<string> CollectModulesHelp(Dictionary<string, object> dict)
+        {
+            lock (m_modulesCommands)
+            {
+                List<string> helpText = new List<string>(m_modulesCommands.Keys);
+                helpText.Sort();
+                return helpText;
             }
-            return result;
         }
+
+//        private List<string> CollectHelp(Dictionary<string, object> dict)
+//        {
+//            List<string> result = new List<string>();
+//
+//            foreach (KeyValuePair<string, object> kvp in dict)
+//            {
+//                if (kvp.Value is Dictionary<string, Object>)
+//                {
+//                    result.AddRange(CollectHelp((Dictionary<string, Object>)kvp.Value));
+//                }
+//                else
+//                {
+//                    if (((CommandInfo)kvp.Value).long_help != String.Empty)
+//                        result.Add(((CommandInfo)kvp.Value).help_text+" - "+
+//                                ((CommandInfo)kvp.Value).long_help);
+//                }
+//            }
+//            return result;
+//        }
         
         /// <summary>
         /// Add a command to those which can be invoked from the console.
@@ -212,21 +267,19 @@ namespace OpenSim.Framework.Console
 
             Dictionary<string, Object> current = tree;
             
-            foreach (string s in parts)
+            foreach (string part in parts)
             {
-                if (current.ContainsKey(s))
+                if (current.ContainsKey(part))
                 {
-                    if (current[s] is Dictionary<string, Object>)
-                    {
-                        current = (Dictionary<string, Object>)current[s];
-                    }
+                    if (current[part] is Dictionary<string, Object>)
+                        current = (Dictionary<string, Object>)current[part];
                     else
                         return;
                 }
                 else
                 {
-                    current[s] = new Dictionary<string, Object>();
-                    current = (Dictionary<string, Object>)current[s];
+                    current[part] = new Dictionary<string, Object>();
+                    current = (Dictionary<string, Object>)current[part];
                 }
             }
 
@@ -250,6 +303,24 @@ namespace OpenSim.Framework.Console
             info.fn = new List<CommandDelegate>();
             info.fn.Add(fn);
             current[String.Empty] = info;
+
+            // Now add command to modules dictionary
+            lock (m_modulesCommands)
+            {
+                List<CommandInfo> commands;
+                if (m_modulesCommands.ContainsKey(module))
+                {
+                    commands = m_modulesCommands[module];
+                }
+                else
+                {
+                    commands = new List<CommandInfo>();
+                    m_modulesCommands[module] = commands;
+                }
+
+//                m_log.DebugFormat("[COMMAND CONSOLE]: Adding to category {0} command {1}", module, command);
+                commands.Add(info);
+            }
         }
 
         public string[] FindNextOption(string[] cmd, bool term)
@@ -607,8 +678,9 @@ namespace OpenSim.Framework.Console
         {
             Commands = new Commands();
 
-            Commands.AddCommand("console", false, "help", "help [<command>]", 
-                    "Get general command list or more detailed help on a specific command", Help);
+            Commands.AddCommand(
+                "Help", false, "help", "help [<item>]",
+                "Display help on a particular command or on a list of commands in a category", Help);
         }
 
         private void Help(string module, string[] cmd)
diff --git a/OpenSim/Framework/GcNotify.cs b/OpenSim/Framework/GcNotify.cs
new file mode 100644
index 0000000..14a22a6
--- /dev/null
+++ b/OpenSim/Framework/GcNotify.cs
@@ -0,0 +1,62 @@
+/*
+ * 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 System.Reflection;
+using log4net;
+
+public class GcNotify
+{
+    private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+    public static bool Enabled
+    {
+        get { return s_initialized; }
+        set
+        {
+            if (!s_initialized && value)
+                new GcNotify();
+
+            s_initialized = value;
+        }
+    }
+
+    private static bool s_initialized = false;
+
+    private GcNotify() {}
+
+    ~GcNotify()
+    {
+        if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload())
+        {
+            m_log.DebugFormat("[GC NOTIFY]: Garbage collection triggered.");
+
+            if (Enabled)
+                new GcNotify();
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/IClientAPI.cs b/OpenSim/Framework/IClientAPI.cs
index c85e599..3f560d0 100644
--- a/OpenSim/Framework/IClientAPI.cs
+++ b/OpenSim/Framework/IClientAPI.cs
@@ -1215,10 +1215,9 @@ namespace OpenSim.Framework
         /// <param name="OrbitalPosition">The orbital position is given in radians, and must be "adjusted" for the linden client, see LLClientView</param>
         void SendSunPos(Vector3 sunPos, Vector3 sunVel, ulong CurrentTime, uint SecondsPerSunCycle, uint SecondsPerYear,
                         float OrbitalPosition);
-
+        
         void SendViewerEffect(ViewerEffectPacket.EffectBlock[] effectBlocks);
         void SendViewerTime(int phase);
-        UUID GetDefaultAnimation(string name);
 
         void SendAvatarProperties(UUID avatarID, string aboutText, string bornOn, Byte[] charterMember, string flAbout,
                                   uint flags, UUID flImageID, UUID imageID, string profileURL, UUID partnerID);
diff --git a/OpenSim/Framework/ICommandConsole.cs b/OpenSim/Framework/ICommandConsole.cs
index d33b9b5..ca0ff93 100644
--- a/OpenSim/Framework/ICommandConsole.cs
+++ b/OpenSim/Framework/ICommandConsole.cs
@@ -40,7 +40,7 @@ namespace OpenSim.Framework
         /// <summary>
         /// Get help for the given help string
         /// </summary>
-        /// <param name="helpParts">Parsed parts of the help string.  If empty then general help is returned.</param>
+        /// <param name="cmd">Parsed parts of the help string.  If empty then general help is returned.</param>
         /// <returns></returns>
         List<string> GetHelp(string[] cmd);
 
diff --git a/OpenSim/Framework/ILandObject.cs b/OpenSim/Framework/ILandObject.cs
index dd73b3f..4f98d7b 100644
--- a/OpenSim/Framework/ILandObject.cs
+++ b/OpenSim/Framework/ILandObject.cs
@@ -71,6 +71,7 @@ namespace OpenSim.Framework
         bool IsEitherBannedOrRestricted(UUID avatar);
         bool IsBannedFromLand(UUID avatar);
         bool IsRestrictedFromLand(UUID avatar);
+        bool IsInLandAccessList(UUID avatar);
         void SendLandUpdateToClient(IClientAPI remote_client);
         void SendLandUpdateToClient(bool snap_selection, IClientAPI remote_client);
         List<LandAccessEntry> CreateAccessListArrayByFlag(AccessList flag);
diff --git a/OpenSim/Framework/MultipartForm.cs b/OpenSim/Framework/MultipartForm.cs
index 90c4007..7a13e8b 100644
--- a/OpenSim/Framework/MultipartForm.cs
+++ b/OpenSim/Framework/MultipartForm.cs
@@ -119,7 +119,7 @@ namespace OpenSim.Framework
                 // Copy the temporary stream to the network stream
                 formDataStream.Seek(0, SeekOrigin.Begin);
                 using (Stream requestStream = request.GetRequestStream())
-                    formDataStream.CopyTo(requestStream, (int)formDataStream.Length);
+                    formDataStream.CopyStream(requestStream, (int)formDataStream.Length);
             }
 
             #endregion Stream Writing
diff --git a/OpenSim/Framework/RegionInfo.cs b/OpenSim/Framework/RegionInfo.cs
index 5ba3863..a505524 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -421,12 +421,18 @@ namespace OpenSim.Framework
             set { m_internalEndPoint = value; }
         }
 
+        /// <summary>
+        /// The x co-ordinate of this region in map tiles (e.g. 1000).
+        /// </summary>
         public uint RegionLocX
         {
             get { return m_regionLocX.Value; }
             set { m_regionLocX = value; }
         }
 
+        /// <summary>
+        /// The y co-ordinate of this region in map tiles (e.g. 1000).
+        /// </summary>
         public uint RegionLocY
         {
             get { return m_regionLocY.Value; }
diff --git a/OpenSim/Framework/SLUtil.cs b/OpenSim/Framework/SLUtil.cs
index b337e03..db4541e 100644
--- a/OpenSim/Framework/SLUtil.cs
+++ b/OpenSim/Framework/SLUtil.cs
@@ -27,7 +27,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Reflection;
+using System.Xml;
 using log4net;
 using OpenMetaverse;
 
@@ -375,4 +377,4 @@ namespace OpenSim.Framework
             return output;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/BaseOpenSimServer.cs b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
index 6a3135e..06a8021 100644
--- a/OpenSim/Framework/Servers/BaseOpenSimServer.cs
+++ b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
@@ -161,43 +161,43 @@ namespace OpenSim.Framework.Servers
                     Notice(String.Format("Console log level is {0}", m_consoleAppender.Threshold));
                 }
                 
-                m_console.Commands.AddCommand("base", false, "quit",
+                m_console.Commands.AddCommand("General", false, "quit",
                         "quit",
                         "Quit the application", HandleQuit);
 
-                m_console.Commands.AddCommand("base", false, "shutdown",
+                m_console.Commands.AddCommand("General", false, "shutdown",
                         "shutdown",
                         "Quit the application", HandleQuit);
 
-                m_console.Commands.AddCommand("base", false, "set log level",
+                m_console.Commands.AddCommand("General", false, "set log level",
                         "set log level <level>",
                         "Set the console logging level", HandleLogLevel);
 
-                m_console.Commands.AddCommand("base", false, "show info",
+                m_console.Commands.AddCommand("General", false, "show info",
                         "show info",
                         "Show general information about the server", HandleShow);
 
-                m_console.Commands.AddCommand("base", false, "show stats",
+                m_console.Commands.AddCommand("General", false, "show stats",
                         "show stats",
                         "Show statistics", HandleShow);
 
-                m_console.Commands.AddCommand("base", false, "show threads",
+                m_console.Commands.AddCommand("General", false, "show threads",
                         "show threads",
                         "Show thread status", HandleShow);
 
-                m_console.Commands.AddCommand("base", false, "show uptime",
+                m_console.Commands.AddCommand("General", false, "show uptime",
                         "show uptime",
                         "Show server uptime", HandleShow);
 
-                m_console.Commands.AddCommand("base", false, "show version",
+                m_console.Commands.AddCommand("General", false, "show version",
                         "show version",
                         "Show server version", HandleShow);
 
-                m_console.Commands.AddCommand("base", false, "threads abort",
+                m_console.Commands.AddCommand("General", false, "threads abort",
                         "threads abort <thread-id>",
                         "Abort a managed thread.  Use \"show threads\" to find possible threads.", HandleThreadsAbort);
 
-                m_console.Commands.AddCommand("base", false, "threads show",
+                m_console.Commands.AddCommand("General", false, "threads show",
                         "threads show",
                         "Show thread status.  Synonym for \"show threads\"",
                         (string module, string[] args) => Notice(GetThreadsReport()));
@@ -269,15 +269,19 @@ namespace OpenSim.Framework.Servers
                     t.Priority,
                     t.ThreadState);
 
-                sb.Append(Environment.NewLine);
+                sb.Append("\n");
             }
 
-            int workers = 0, ports = 0, maxWorkers = 0, maxPorts = 0;
-            ThreadPool.GetAvailableThreads(out workers, out ports);
-            ThreadPool.GetMaxThreads(out maxWorkers, out maxPorts);
+            sb.Append("\n");
 
-            sb.Append(Environment.NewLine + "*** ThreadPool threads ***"  + Environment.NewLine);
-            sb.Append("workers: " + (maxWorkers - workers) + " (" + maxWorkers + "); ports: " + (maxPorts - ports) + " (" + maxPorts + ")" + Environment.NewLine);
+            // For some reason mono 2.6.7 returns an empty threads set!  Not going to confuse people by reporting
+            // zero active threads.
+            int totalThreads = Process.GetCurrentProcess().Threads.Count;
+            if (totalThreads > 0)
+                sb.AppendFormat("Total threads active: {0}\n\n", totalThreads);
+
+            sb.Append("Main threadpool (excluding script engine pools)\n");
+            sb.Append(Util.GetThreadPoolReport());
 
             return sb.ToString();
         }
diff --git a/OpenSim/Framework/Statistics/BaseStatsCollector.cs b/OpenSim/Framework/Statistics/BaseStatsCollector.cs
index a1841c5..c9e57ce 100644
--- a/OpenSim/Framework/Statistics/BaseStatsCollector.cs
+++ b/OpenSim/Framework/Statistics/BaseStatsCollector.cs
@@ -26,8 +26,8 @@
  */
 
 using System;
+using System.Diagnostics;
 using System.Text;
-
 using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 
@@ -46,8 +46,12 @@ namespace OpenSim.Framework.Statistics
             sb.Append(Environment.NewLine);
             sb.Append(
                 string.Format(
-                    "Allocated to OpenSim : {0} MB" + Environment.NewLine,
+                    "Allocated to OpenSim objects: {0} MB\n",
                     Math.Round(GC.GetTotalMemory(false) / 1024.0 / 1024.0)));
+            sb.Append(
+                string.Format(
+                    "Process memory              : {0} MB\n",
+                    Math.Round(Process.GetCurrentProcess().WorkingSet64 / 1024.0 / 1024.0)));
 
             return sb.ToString();
         }
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index efa4a7b..e03bb74 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -35,7 +35,7 @@ using System.IO;
 using System.IO.Compression;
 using System.Net;
 using System.Net.Sockets;
-using System.Reflection;

+using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
@@ -81,12 +81,15 @@ namespace OpenSim.Framework
 
         private static uint nextXferID = 5000;
         private static Random randomClass = new Random();
+
         // Get a list of invalid file characters (OS dependent)
         private static string regexInvalidFileChars = "[" + new String(Path.GetInvalidFileNameChars()) + "]";
         private static string regexInvalidPathChars = "[" + new String(Path.GetInvalidPathChars()) + "]";
         private static object XferLock = new object();
-        /// <summary>Thread pool used for Util.FireAndForget if
-        /// FireAndForgetMethod.SmartThreadPool is used</summary>
+
+        /// <summary>
+        /// Thread pool used for Util.FireAndForget if FireAndForgetMethod.SmartThreadPool is used
+        /// </summary>
         private static SmartThreadPool m_ThreadPool;
 
         // Unix-epoch starts at January 1st 1970, 00:00:00 UTC. And all our times in the server are (or at least should be) in UTC.
@@ -144,7 +147,6 @@ namespace OpenSim.Framework
             return lerp(y, lerp(x, a, b), lerp(x, c, d));
         }
 
-
         public static Encoding UTF8 = Encoding.UTF8;
 
         /// <value>
@@ -376,20 +378,20 @@ namespace OpenSim.Framework
             }
 
             return sb.ToString();
-        }

-

-        /// <summary>

-        /// Is the platform Windows?

-        /// </summary>

-        /// <returns>true if so, false otherwise</returns>

-        public static bool IsWindows()

-        {

-            PlatformID platformId = Environment.OSVersion.Platform;

-

-            return (platformId == PlatformID.Win32NT

-                || platformId == PlatformID.Win32S

-                || platformId == PlatformID.Win32Windows

-                || platformId == PlatformID.WinCE);

+        }
+
+        /// <summary>
+        /// Is the platform Windows?
+        /// </summary>
+        /// <returns>true if so, false otherwise</returns>
+        public static bool IsWindows()
+        {
+            PlatformID platformId = Environment.OSVersion.Platform;
+
+            return (platformId == PlatformID.Win32NT
+                || platformId == PlatformID.Win32S
+                || platformId == PlatformID.Win32Windows
+                || platformId == PlatformID.WinCE);
         }
 
         public static bool LoadArchSpecificWindowsDll(string libraryName)
@@ -1502,27 +1504,27 @@ namespace OpenSim.Framework
             }
 
             return data;
-        }

-

-        /// <summary>

-        /// Used to trigger an early library load on Windows systems.

-        /// </summary>

-        /// <remarks>

-        /// Required to get 32-bit and 64-bit processes to automatically use the

-        /// appropriate native library.

-        /// </remarks>

-        /// <param name="dllToLoad"></param>

-        /// <returns></returns>

-        [DllImport("kernel32.dll")]

-        public static extern IntPtr LoadLibrary(string dllToLoad);

-

-        /// <summary>

-        /// Determine whether the current process is 64 bit

-        /// </summary>

-        /// <returns>true if so, false if not</returns>

-        public static bool Is64BitProcess()

-        {

-            return IntPtr.Size == 8;

+        }
+
+        /// <summary>
+        /// Used to trigger an early library load on Windows systems.
+        /// </summary>
+        /// <remarks>
+        /// Required to get 32-bit and 64-bit processes to automatically use the
+        /// appropriate native library.
+        /// </remarks>
+        /// <param name="dllToLoad"></param>
+        /// <returns></returns>
+        [DllImport("kernel32.dll")]
+        public static extern IntPtr LoadLibrary(string dllToLoad);
+
+        /// <summary>
+        /// Determine whether the current process is 64 bit
+        /// </summary>
+        /// <returns>true if so, false if not</returns>
+        public static bool Is64BitProcess()
+        {
+            return IntPtr.Size == 8;
         }
 
         #region FireAndForget Threading Pattern
@@ -1671,6 +1673,61 @@ namespace OpenSim.Framework
             }
         }
 
+        /// <summary>
+        /// Get a thread pool report.
+        /// </summary>
+        /// <returns></returns>
+        public static string GetThreadPoolReport()
+        {
+            string threadPoolUsed = null;
+            int maxThreads = 0;
+            int minThreads = 0;
+            int allocatedThreads = 0;
+            int inUseThreads = 0;
+            int waitingCallbacks = 0;
+            int completionPortThreads = 0;
+
+            StringBuilder sb = new StringBuilder();
+            if (FireAndForgetMethod == FireAndForgetMethod.SmartThreadPool)
+            {
+                threadPoolUsed = "SmartThreadPool";
+                maxThreads = m_ThreadPool.MaxThreads;
+                minThreads = m_ThreadPool.MinThreads;
+                inUseThreads = m_ThreadPool.InUseThreads;
+                allocatedThreads = m_ThreadPool.ActiveThreads;
+                waitingCallbacks = m_ThreadPool.WaitingCallbacks;
+            }
+            else if (
+                FireAndForgetMethod == FireAndForgetMethod.UnsafeQueueUserWorkItem
+                    || FireAndForgetMethod == FireAndForgetMethod.UnsafeQueueUserWorkItem)
+            {
+                threadPoolUsed = "BuiltInThreadPool";
+                ThreadPool.GetMaxThreads(out maxThreads, out completionPortThreads);
+                ThreadPool.GetMinThreads(out minThreads, out completionPortThreads);
+                int availableThreads;
+                ThreadPool.GetAvailableThreads(out availableThreads, out completionPortThreads);
+                inUseThreads = maxThreads - availableThreads;
+                allocatedThreads = -1;
+                waitingCallbacks = -1;
+            }
+
+            if (threadPoolUsed != null)
+            {
+                sb.AppendFormat("Thread pool used           : {0}\n", threadPoolUsed);
+                sb.AppendFormat("Max threads                : {0}\n", maxThreads);
+                sb.AppendFormat("Min threads                : {0}\n", minThreads);
+                sb.AppendFormat("Allocated threads          : {0}\n", allocatedThreads < 0 ? "not applicable" : allocatedThreads.ToString());
+                sb.AppendFormat("In use threads             : {0}\n", inUseThreads);
+                sb.AppendFormat("Work items waiting         : {0}\n", waitingCallbacks < 0 ? "not available" : waitingCallbacks.ToString());
+            }
+            else
+            {
+                sb.AppendFormat("Thread pool not used\n");
+            }
+
+            return sb.ToString();
+        }
+
         private static object SmartThreadPoolCallback(object o)
         {
             object[] array = (object[])o;
@@ -1701,13 +1758,26 @@ namespace OpenSim.Framework
         /// and negative every 24.9 days. Subtracts the passed value (previously fetched by
         /// 'EnvironmentTickCount()') and accounts for any wrapping.
         /// </summary>
+        /// <param name="newValue"></param>
+        /// <param name="prevValue"></param>
         /// <returns>subtraction of passed prevValue from current Environment.TickCount</returns>
-        public static Int32 EnvironmentTickCountSubtract(Int32 prevValue)
+        public static Int32 EnvironmentTickCountSubtract(Int32 newValue, Int32 prevValue)
         {
-            Int32 diff = EnvironmentTickCount() - prevValue;
+            Int32 diff = newValue - prevValue;
             return (diff >= 0) ? diff : (diff + EnvironmentTickCountMask + 1);
         }
 
+        /// <summary>
+        /// Environment.TickCount is an int but it counts all 32 bits so it goes positive
+        /// and negative every 24.9 days. Subtracts the passed value (previously fetched by
+        /// 'EnvironmentTickCount()') and accounts for any wrapping.
+        /// </summary>
+        /// <returns>subtraction of passed prevValue from current Environment.TickCount</returns>
+        public static Int32 EnvironmentTickCountSubtract(Int32 prevValue)
+        {
+            return EnvironmentTickCountSubtract(EnvironmentTickCount(), prevValue);
+        }
+
         // Returns value of Tick Count A - TickCount B accounting for wrapping of TickCount
         // Assumes both tcA and tcB came from previous calls to Util.EnvironmentTickCount().
         // A positive return value indicates A occured later than B
@@ -1870,11 +1940,12 @@ namespace OpenSim.Framework
         #region Universal User Identifiers
        /// <summary>
         /// </summary>
-        /// <param name="value">uuid[;endpoint[;name]]</param>
-        /// <param name="uuid"></param>
-        /// <param name="url"></param>
-        /// <param name="firstname"></param>
-        /// <param name="lastname"></param>
+        /// <param name="value">uuid[;endpoint[;first last[;secret]]]</param>
+        /// <param name="uuid">the uuid part</param>
+        /// <param name="url">the endpoint part (e.g. http://foo.com)</param>
+        /// <param name="firstname">the first name part (e.g. Test)</param>
+        /// <param name="lastname">the last name part (e.g User)</param>
+        /// <param name="secret">the secret part</param>
         public static bool ParseUniversalUserIdentifier(string value, out UUID uuid, out string url, out string firstname, out string lastname, out string secret)
         {
             uuid = UUID.Zero; url = string.Empty; firstname = "Unknown"; lastname = "User"; secret = string.Empty;
@@ -1903,31 +1974,64 @@ namespace OpenSim.Framework
         }
 
         /// <summary>
-        /// 
+        /// Produces a universal (HG) system-facing identifier given the information
         /// </summary>
         /// <param name="acircuit"></param>
-        /// <returns>uuid[;endpoint[;name]]</returns>
+        /// <returns>uuid[;homeURI[;first last]]</returns>
         public static string ProduceUserUniversalIdentifier(AgentCircuitData acircuit)
         {
             if (acircuit.ServiceURLs.ContainsKey("HomeURI"))
+                return UniversalIdentifier(acircuit.AgentID, acircuit.firstname, acircuit.lastname, acircuit.ServiceURLs["HomeURI"].ToString());
+            else
+                return acircuit.AgentID.ToString();
+        }
+
+        /// <summary>
+        /// Produces a universal (HG) system-facing identifier given the information
+        /// </summary>
+        /// <param name="id">UUID of the user</param>
+        /// <param name="firstName">first name (e.g Test)</param>
+        /// <param name="lastName">last name (e.g. User)</param>
+        /// <param name="homeURI">homeURI (e.g. http://foo.com)</param>
+        /// <returns>a string of the form uuid[;homeURI[;first last]]</returns>
+        public static string UniversalIdentifier(UUID id, String firstName, String lastName, String homeURI)
+        {
+            string agentsURI = homeURI;
+            if (!agentsURI.EndsWith("/"))
+                agentsURI += "/";
+
+            // This is ugly, but there's no other way, given that the name is changed
+            // in the agent circuit data for foreigners
+            if (lastName.Contains("@"))
             {
-                string agentsURI = acircuit.ServiceURLs["HomeURI"].ToString();
-                if (!agentsURI.EndsWith("/"))
-                    agentsURI += "/";
+                string[] parts = firstName.Split(new char[] { '.' });
+                if (parts.Length == 2)
+                    return id.ToString() + ";" + agentsURI + ";" + parts[0] + " " + parts[1];
+            }
+            return id.ToString() + ";" + agentsURI + ";" + firstName + " " + lastName;
 
-                // This is ugly, but there's no other way, given that the name is changed
-                // in the agent circuit data for foreigners
-                if (acircuit.lastname.Contains("@"))
-                {
-                    string[] parts = acircuit.firstname.Split(new char[] { '.' });
-                    if (parts.Length == 2)
-                        return acircuit.AgentID.ToString() + ";" + agentsURI + ";" + parts[0] + " " + parts[1];
-                }
-                return acircuit.AgentID.ToString() + ";" + agentsURI + ";" + acircuit.firstname + " " + acircuit.lastname;
+        }
+
+        /// <summary>
+        /// Produces a universal (HG) user-facing name given the information
+        /// </summary>
+        /// <param name="firstName"></param>
+        /// <param name="lastName"></param>
+        /// <param name="homeURI"></param>
+        /// <returns>string of the form first.last @foo.com or first last</returns>
+        public static string UniversalName(String firstName, String lastName, String homeURI)
+        {
+            Uri uri = null;
+            try
+            {
+                uri = new Uri(homeURI);
             }
-            else
-                return acircuit.AgentID.ToString();
-        }        
+            catch (UriFormatException)
+            {
+                return firstName + " " + lastName;
+            }
+            return firstName + "." + lastName + " " + "@" + uri.Authority;
+        }
         #endregion
     }
 }
diff --git a/OpenSim/Framework/WebUtil.cs b/OpenSim/Framework/WebUtil.cs
index af25da9..ead8f46 100644
--- a/OpenSim/Framework/WebUtil.cs
+++ b/OpenSim/Framework/WebUtil.cs
@@ -63,6 +63,31 @@ namespace OpenSim.Framework
         // a "long" call for warning & debugging purposes
         public const int LongCallTime = 500;
 
+        // dictionary of end points
+        private static Dictionary<string,object> m_endpointSerializer = new Dictionary<string,object>();
+        
+
+        private static object EndPointLock(string url)
+        {
+            System.Uri uri = new System.Uri(url);
+            string endpoint = string.Format("{0}:{1}",uri.Host,uri.Port);
+
+            lock (m_endpointSerializer)
+            {
+                object eplock = null;
+
+                if (! m_endpointSerializer.TryGetValue(endpoint,out eplock))
+                {
+                    eplock = new object();
+                    m_endpointSerializer.Add(endpoint,eplock);
+                    // m_log.WarnFormat("[WEB UTIL] add a new host to end point serializer {0}",endpoint);
+                }
+
+                return eplock;
+            }
+        }
+        
+                
         #region JSONRequest
 
         /// <summary>
@@ -96,6 +121,14 @@ namespace OpenSim.Framework
         
         public static OSDMap ServiceOSDRequest(string url, OSDMap data, string method, int timeout, bool compressed)
         {
+            lock (EndPointLock(url))
+            {
+                return ServiceOSDRequestWorker(url,data,method,timeout,compressed);
+            }
+        }
+
+        private static OSDMap ServiceOSDRequestWorker(string url, OSDMap data, string method, int timeout, bool compressed)
+        {
             int reqnum = m_requestNumber++;
             // m_log.DebugFormat("[WEB UTIL]: <{0}> start osd request for {1}, method {2}",reqnum,url,method);
 
@@ -248,6 +281,14 @@ namespace OpenSim.Framework
         
         public static OSDMap ServiceFormRequest(string url, NameValueCollection data, int timeout)
         {
+            lock (EndPointLock(url))
+            {
+                return ServiceFormRequestWorker(url,data,timeout);
+            }
+        }
+
+        private static OSDMap ServiceFormRequestWorker(string url, NameValueCollection data, int timeout)
+        {
             int reqnum = m_requestNumber++;
             string method = (data != null && data["RequestMethod"] != null) ? data["RequestMethod"] : "unknown";
             // m_log.DebugFormat("[WEB UTIL]: <{0}> start form request for {1}, method {2}",reqnum,url,method);
@@ -469,8 +510,13 @@ namespace OpenSim.Framework
         /// <remarks>
         /// Copying begins at the streams' current positions. The positions are
         /// NOT reset after copying is complete.
+        /// NOTE!! .NET 4.0 adds the method 'Stream.CopyTo(stream, bufferSize)'.
+        /// This function could be replaced with that method once we move
+        /// totally to .NET 4.0. For versions before, this routine exists.
+        /// This routine used to be named 'CopyTo' but the int parameter has
+        /// a different meaning so this method was renamed to avoid any confusion.
         /// </remarks>
-        public static int CopyTo(this Stream copyFrom, Stream copyTo, int maximumBytesToCopy)
+        public static int CopyStream(this Stream copyFrom, Stream copyTo, int maximumBytesToCopy)
         {
             byte[] buffer = new byte[4096];
             int readBytes;