46 files changed, 2367 insertions, 482 deletions
diff --git a/OpenSim/Framework/AssemblyInfo.cs b/OpenSim/Framework/AssemblyInfo.cs
index adeaeb2..02986d5 100644
--- a/OpenSim/Framework/AssemblyInfo.cs
+++ b/OpenSim/Framework/AssemblyInfo.cs
@@ -59,5 +59,5 @@ using System.Runtime.InteropServices;
 //      Revision
 //
-[assembly : AssemblyVersion("0.6.5.*")]
+[assembly : AssemblyVersion("0.7.5.*")]
 [assembly : AssemblyFileVersion("0.6.5.0")]
 \ No newline at end of file
diff --git a/OpenSim/Framework/AssetLoader/Filesystem/Properties/AssemblyInfo.cs b/OpenSim/Framework/AssetLoader/Filesystem/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..0498ed4
--- /dev/null
+++ b/OpenSim/Framework/AssetLoader/Filesystem/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.AssetLoader.Filesystem")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8cb9cf69-4771-4d3a-a2ba-bac7230de326")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/AssetPermissions.cs b/OpenSim/Framework/AssetPermissions.cs
new file mode 100644
index 0000000..4a905c2
--- /dev/null
+++ b/OpenSim/Framework/AssetPermissions.cs
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Nini.Config;
+using log4net;
+using OpenMetaverse;
+namespace OpenSim.Framework
+{
+    public class AssetPermissions
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(
+            MethodBase.GetCurrentMethod().DeclaringType);
+        private bool[] m_DisallowExport, m_DisallowImport;
+        private string[] m_AssetTypeNames;
+        public AssetPermissions(IConfig config)
+        {
+            Type enumType = typeof(AssetType);
+            m_AssetTypeNames = Enum.GetNames(enumType);
+            for (int i = 0; i < m_AssetTypeNames.Length; i++)
+                m_AssetTypeNames[i] = m_AssetTypeNames[i].ToLower();
+            int n = Enum.GetValues(enumType).Length;
+            m_DisallowExport = new bool[n];
+            m_DisallowImport = new bool[n];
+            LoadPermsFromConfig(config, "DisallowExport", m_DisallowExport);
+            LoadPermsFromConfig(config, "DisallowImport", m_DisallowImport);
+        }
+        private void LoadPermsFromConfig(IConfig assetConfig, string variable, bool[] bitArray)
+        {
+            if (assetConfig == null)
+                return;
+            string perms = assetConfig.GetString(variable, String.Empty);
+            string[] parts = perms.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+            foreach (string s in parts)
+            {
+                int index = Array.IndexOf(m_AssetTypeNames, s.Trim().ToLower());
+                if (index >= 0)
+                    bitArray[index] = true;
+                else
+                    m_log.WarnFormat("[Asset Permissions]: Invalid AssetType {0}", s);
+            }
+        }
+        public bool AllowedExport(sbyte type)
+        {
+            string assetTypeName = ((AssetType)type).ToString();
+            int index = Array.IndexOf(m_AssetTypeNames, assetTypeName.ToLower());
+            if (index >= 0 && m_DisallowExport[index])
+            {
+                m_log.DebugFormat("[Asset Permissions]: Export denied: configuration does not allow export of AssetType {0}", assetTypeName);
+                return false;
+            }
+            return true;
+        }
+        public bool AllowedImport(sbyte type)
+        {
+            string assetTypeName = ((AssetType)type).ToString();
+            int index = Array.IndexOf(m_AssetTypeNames, assetTypeName.ToLower());
+            if (index >= 0 && m_DisallowImport[index])
+            {
+                m_log.DebugFormat("[Asset Permissions]: Import denied: configuration does not allow import of AssetType {0}", assetTypeName);
+                return false;
+            }
+            return true;
+        }
+    }
+}
diff --git a/OpenSim/Framework/AvatarAppearance.cs b/OpenSim/Framework/AvatarAppearance.cs
index c5d9641..1638541 100644
--- a/OpenSim/Framework/AvatarAppearance.cs
+++ b/OpenSim/Framework/AvatarAppearance.cs
@@ -358,6 +358,9 @@ namespace OpenSim.Framework
            SetVisualParams(visualParams);
        }
+        /// <summary>
+        /// Set avatar height by a calculation based on their visual parameters.
+        /// </summary>
        public virtual void SetHeight()
        {
            // Start with shortest possible female avatar height
diff --git a/OpenSim/Framework/Cache.cs b/OpenSim/Framework/Cache.cs
index 79e20fc..31cab4a 100644
--- a/OpenSim/Framework/Cache.cs
+++ b/OpenSim/Framework/Cache.cs
@@ -199,7 +199,14 @@ namespace OpenSim.Framework
    //
    public class Cache
    {
+        /// <summary>
+        /// Must only be accessed under lock.
+        /// </summary>
        private List<CacheItemBase> m_Index = new List<CacheItemBase>();
+        /// <summary>
+        /// Must only be accessed under m_Index lock.
+        /// </summary>
        private Dictionary<string, CacheItemBase> m_Lookup =
            new Dictionary<string, CacheItemBase>();
@@ -320,19 +327,19 @@ namespace OpenSim.Framework
            {
                if (m_Lookup.ContainsKey(index))
                    item = m_Lookup[index];
-            }
-            if (item == null)
+                if (item == null)
-            {
+                {
+                    Expire(true);
+                    return null;
+                }
+    
+                item.hits++;
+                item.lastUsed = DateTime.Now;
+    
                Expire(true);
-                return null;
            }
-            item.hits++;
-            item.lastUsed = DateTime.Now;
-            Expire(true);
            return item;
        }
@@ -385,7 +392,10 @@ namespace OpenSim.Framework
        //
        public Object Find(Predicate<CacheItemBase> d)
        {
-            CacheItemBase item = m_Index.Find(d);
+            CacheItemBase item;
+            lock (m_Index)
+                item = m_Index.Find(d);
            if (item == null)
                return null;
@@ -419,12 +429,12 @@ namespace OpenSim.Framework
        public virtual void Store(string index, Object data, Type container,
                Object[] parameters)
        {
-            Expire(false);
            CacheItemBase item;
            lock (m_Index)
            {
+                Expire(false);
                if (m_Index.Contains(new CacheItemBase(index)))
                {
                    if ((m_Flags & CacheFlags.AllowUpdate) != 0)
@@ -450,9 +460,17 @@ namespace OpenSim.Framework
                m_Index.Add(item);
                m_Lookup[index] = item;
            }
            item.Store(data);
        }
+        /// <summary>
+        /// Expire items as appropriate.
+        /// </summary>
+        /// <remarks>
+        /// Callers must lock m_Index.
+        /// </remarks>
+        /// <param name='getting'></param>
        protected virtual void Expire(bool getting)
        {
            if (getting && (m_Strategy == CacheStrategy.Aggressive))
@@ -475,12 +493,10 @@ namespace OpenSim.Framework
            switch (m_Strategy)
            {
-            case CacheStrategy.Aggressive:
+                case CacheStrategy.Aggressive:
-                if (Count < Size)
+                    if (Count < Size)
-                    return;
+                        return;
-                lock (m_Index)
-                {
                    m_Index.Sort(new SortLRU());
                    m_Index.Reverse();
@@ -490,7 +506,7 @@ namespace OpenSim.Framework
                    ExpireDelegate doExpire = OnExpire;
-                if (doExpire != null)
+                    if (doExpire != null)
                    {
                        List<CacheItemBase> candidates =
                                m_Index.GetRange(target, Count - target);
@@ -513,27 +529,34 @@ namespace OpenSim.Framework
                        foreach (CacheItemBase item in m_Index)
                            m_Lookup[item.uuid] = item;
                    }
-                }
-                break;
+                    break;
-            default:
-                break;
+                    default:
+                        break;
            }
        }
        public void Invalidate(string uuid)
        {
-            if (!m_Lookup.ContainsKey(uuid))
+            lock (m_Index)
-                return;
+            {
+                if (!m_Lookup.ContainsKey(uuid))
+                    return;
-            CacheItemBase item = m_Lookup[uuid];
+                CacheItemBase item = m_Lookup[uuid];
-            m_Lookup.Remove(uuid);
+                m_Lookup.Remove(uuid);
-            m_Index.Remove(item);
+                m_Index.Remove(item);
+            }
        }
        public void Clear()
        {
-            m_Index.Clear();
+            lock (m_Index)
-            m_Lookup.Clear();
+            {
+                m_Index.Clear();
+                m_Lookup.Clear();
+            }
        }
    }
-}
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/Client/IClientChat.cs b/OpenSim/Framework/Client/IClientChat.cs
index 078ea9b..86b1faa 100644
--- a/OpenSim/Framework/Client/IClientChat.cs
+++ b/OpenSim/Framework/Client/IClientChat.cs
@@ -33,7 +33,8 @@ namespace OpenSim.Framework.Client
    {
        event ChatMessage OnChatFromClient;
-        void SendChatMessage(string message, byte type, Vector3 fromPos, string fromName, UUID fromAgentID, byte source,
+        void SendChatMessage(
-                             byte audible);
+            string message, byte type, Vector3 fromPos, string fromName, UUID fromAgentID, UUID ownerID, byte source,
+            byte audible);
    }
-}
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/Communications/Properties/AssemblyInfo.cs b/OpenSim/Framework/Communications/Properties/AssemblyInfo.cs
index 2df6ace..6d1c03a 100644
--- a/OpenSim/Framework/Communications/Properties/AssemblyInfo.cs
+++ b/OpenSim/Framework/Communications/Properties/AssemblyInfo.cs
@@ -32,12 +32,12 @@ using System.Runtime.InteropServices;
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
-[assembly : AssemblyTitle("OpenGrid.Framework.Communications")]
+[assembly : AssemblyTitle("OpenSim.Framework.Communications")]
 [assembly : AssemblyDescription("")]
 [assembly : AssemblyConfiguration("")]
 [assembly : AssemblyCompany("http://opensimulator.org")]
-[assembly : AssemblyProduct("OpenGrid.Framework.Communications")]
+[assembly : AssemblyProduct("OpenSim")]
-[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2009")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers")]
 [assembly : AssemblyTrademark("")]
 [assembly : AssemblyCulture("")]
@@ -61,5 +61,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Revision and Build Numbers
 // by using the '*' as shown below:
-[assembly : AssemblyVersion("0.6.5.*")]
+[assembly : AssemblyVersion("0.7.5.*")]
 [assembly : AssemblyFileVersion("0.6.5.0")]
diff --git a/OpenSim/Framework/Configuration/HTTP/Properties/AssemblyInfo.cs b/OpenSim/Framework/Configuration/HTTP/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..0674656
--- /dev/null
+++ b/OpenSim/Framework/Configuration/HTTP/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.Configuration.HTTP")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator develoeprs")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("cb78b672-d000-4f93-88f9-dae151cc0061")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/Configuration/XML/Properties/AssemblyInfo.cs b/OpenSim/Framework/Configuration/XML/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..1095b23
--- /dev/null
+++ b/OpenSim/Framework/Configuration/XML/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.Configuration.XML")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("eeb880df-0112-4c3d-87ed-b2108d614c55")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/Console/AssemblyInfo.cs b/OpenSim/Framework/Console/AssemblyInfo.cs
index 75e35bf..37c7304 100644
--- a/OpenSim/Framework/Console/AssemblyInfo.cs
+++ b/OpenSim/Framework/Console/AssemblyInfo.cs
@@ -39,7 +39,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("http://opensimulator.org")]
 [assembly : AssemblyProduct("ServerConsole")]
-[assembly: AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2009")]
+[assembly: AssemblyCopyright("Copyright (c) OpenSimulator.org Developers")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
@@ -55,4 +55,4 @@ using System.Runtime.InteropServices;
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
-[assembly : AssemblyVersion("0.6.5.*")]
+[assembly : AssemblyVersion("0.7.5.*")]
diff --git a/OpenSim/Framework/Console/ConsoleUtil.cs b/OpenSim/Framework/Console/ConsoleUtil.cs
new file mode 100644
index 0000000..16a63e0
--- /dev/null
+++ b/OpenSim/Framework/Console/ConsoleUtil.cs
@@ -0,0 +1,228 @@
+/*
+ * 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.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using log4net;
+using OpenMetaverse;
+namespace OpenSim.Framework.Console
+{
+    public class ConsoleUtil
+    {
+    //    private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        public const int LocalIdNotFound = 0;
+    
+        /// <summary>
+        /// Used by modules to display stock co-ordinate help, though possibly this should be under some general section
+        /// rather than in each help summary.
+        /// </summary>
+        public const string CoordHelp
+    = @"Each component of the coord is comma separated.  There must be no spaces between the commas.
+    If you don't care about the z component you can simply omit it.
+    If you don't care about the x or y components then you can leave them blank (though a comma is still required)
+    If you want to specify the maxmimum value of a component then you can use ~ instead of a number
+    If you want to specify the minimum value of a component then you can use -~ instead of a number
+    e.g.
+    delete object pos 20,20,20 to 40,40,40
+    delete object pos 20,20 to 40,40
+    delete object pos ,20,20 to ,40,40
+    delete object pos ,,30 to ,,~
+    delete object pos ,,-~ to ,,30";
+    
+        public const string MinRawConsoleVectorValue = "-~";
+        public const string MaxRawConsoleVectorValue = "~";
+    
+        public const string VectorSeparator = ",";
+        public static char[] VectorSeparatorChars = VectorSeparator.ToCharArray();
+        /// <summary>
+        /// Check if the given file path exists.
+        /// </summary>
+        /// <remarks>If not, warning is printed to the given console.</remarks>
+        /// <returns>true if the file does not exist, false otherwise.</returns>
+        /// <param name='console'></param>
+        /// <param name='path'></param>
+        public static bool CheckFileDoesNotExist(ICommandConsole console, string path)
+        {
+            if (File.Exists(path))
+            {
+                console.OutputFormat("File {0} already exists.  Please move or remove it.", path);
+                return false;
+            }
+            return true;
+        }
+    
+        /// <summary>
+        /// Try to parse a console UUID from the console.
+        /// </summary>
+        /// <remarks>
+        /// Will complain to the console if parsing fails.
+        /// </remarks>
+        /// <returns></returns>
+        /// <param name='console'>If null then no complaint is printed.</param>
+        /// <param name='rawUuid'></param>
+        /// <param name='uuid'></param>
+        public static bool TryParseConsoleUuid(ICommandConsole console, string rawUuid, out UUID uuid)
+        {
+            if (!UUID.TryParse(rawUuid, out uuid))
+            {
+                if (console != null)
+                    console.OutputFormat("{0} is not a valid uuid", rawUuid);
+                return false;
+            }
+    
+            return true;
+        }
+        public static bool TryParseConsoleLocalId(ICommandConsole console, string rawLocalId, out uint localId)
+        {
+            if (!uint.TryParse(rawLocalId, out localId))
+            {
+                if (console != null)
+                    console.OutputFormat("{0} is not a valid local id", localId);
+                return false;
+            }
+            if (localId == 0)
+            {
+                if (console != null)
+                    console.OutputFormat("{0} is not a valid local id - it must be greater than 0", localId);
+                return false;
+            }
+            return true;
+        }
+        /// <summary>
+        /// Tries to parse the input as either a UUID or a local ID.
+        /// </summary>
+        /// <returns>true if parsing succeeded, false otherwise.</returns>
+        /// <param name='console'></param>
+        /// <param name='rawId'></param>
+        /// <param name='uuid'></param>
+        /// <param name='localId'>
+        /// Will be set to ConsoleUtil.LocalIdNotFound if parsing result was a UUID or no parse succeeded.
+        /// </param>
+        public static bool TryParseConsoleId(ICommandConsole console, string rawId, out UUID uuid, out uint localId)
+        {
+            if (TryParseConsoleUuid(null, rawId, out uuid))
+            {
+                localId = LocalIdNotFound;
+                return true;
+            }
+            if (TryParseConsoleLocalId(null, rawId, out localId))
+            {
+                return true;
+            }
+            if (console != null)
+                console.OutputFormat("{0} is not a valid UUID or local id", rawId);
+            return false;
+        }
+    
+        /// <summary>
+        /// Convert a minimum vector input from the console to an OpenMetaverse.Vector3
+        /// </summary>
+        /// <param name='rawConsoleVector'>/param>
+        /// <param name='vector'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleMinVector(string rawConsoleVector, out Vector3 vector)
+        {
+            return TryParseConsoleVector(rawConsoleVector, c => float.MinValue.ToString(), out vector);
+        }
+    
+        /// <summary>
+        /// Convert a maximum vector input from the console to an OpenMetaverse.Vector3
+        /// </summary>
+        /// <param name='rawConsoleVector'>/param>
+        /// <param name='vector'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleMaxVector(string rawConsoleVector, out Vector3 vector)
+        {
+            return TryParseConsoleVector(rawConsoleVector, c => float.MaxValue.ToString(), out vector);
+        }
+    
+        /// <summary>
+        /// Convert a vector input from the console to an OpenMetaverse.Vector3
+        /// </summary>
+        /// <param name='rawConsoleVector'>
+        /// A string in the form <x>,<y>,<z> where there is no space between values.
+        /// Any component can be missing (e.g. ,,40).  blankComponentFunc is invoked to replace the blank with a suitable value
+        /// Also, if the blank component is at the end, then the comma can be missed off entirely (e.g. 40,30 or 40)
+        /// The strings "~" and "-~" are valid in components.  The first substitutes float.MaxValue whilst the second is float.MinValue
+        /// Other than that, component values must be numeric.
+        /// </param>
+        /// <param name='blankComponentFunc'></param>
+        /// <param name='vector'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleVector(
+            string rawConsoleVector, Func<string, string> blankComponentFunc, out Vector3 vector)
+        {
+            List<string> components = rawConsoleVector.Split(VectorSeparatorChars).ToList();
+    
+            if (components.Count < 1 || components.Count > 3)
+            {
+                vector = Vector3.Zero;
+                return false;
+            }
+    
+            for (int i = components.Count; i < 3; i++)
+                components.Add("");
+    
+            List<string> semiDigestedComponents
+                = components.ConvertAll<string>(
+                    c =>
+                    {
+                        if (c == "")
+                            return blankComponentFunc.Invoke(c);
+                        else if (c == MaxRawConsoleVectorValue)
+                            return float.MaxValue.ToString();
+                        else if (c == MinRawConsoleVectorValue)
+                            return float.MinValue.ToString();
+                        else
+                            return c;
+                    });
+    
+            string semiDigestedConsoleVector = string.Join(VectorSeparator, semiDigestedComponents.ToArray());
+    
+    //        m_log.DebugFormat("[CONSOLE UTIL]: Parsing {0} into OpenMetaverse.Vector3", semiDigestedConsoleVector);
+    
+            return Vector3.TryParse(semiDigestedConsoleVector, out vector);
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/Constants.cs b/OpenSim/Framework/Constants.cs
index 1b1aaf2..a2eb5ee 100644
--- a/OpenSim/Framework/Constants.cs
+++ b/OpenSim/Framework/Constants.cs
@@ -31,6 +31,7 @@ namespace OpenSim.Framework
    public class Constants
    {
        public const uint RegionSize = 256;
+        public const uint RegionHeight = 4096;
        public const byte TerrainPatchSize = 16;
        public const string DefaultTexture = "89556747-24cb-43ed-920b-47caed15465f";
diff --git a/OpenSim/Framework/EstateSettings.cs b/OpenSim/Framework/EstateSettings.cs
index 9020761..e03750b 100644
--- a/OpenSim/Framework/EstateSettings.cs
+++ b/OpenSim/Framework/EstateSettings.cs
@@ -419,11 +419,11 @@ namespace OpenSim.Framework
        public void SetFromFlags(ulong regionFlags)
        {
-            ResetHomeOnTeleport = ((regionFlags & (ulong)RegionFlags.ResetHomeOnTeleport) == (ulong)RegionFlags.ResetHomeOnTeleport);
+            ResetHomeOnTeleport = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.ResetHomeOnTeleport) == (ulong)OpenMetaverse.RegionFlags.ResetHomeOnTeleport);
-            BlockDwell = ((regionFlags & (ulong)RegionFlags.BlockDwell) == (ulong)RegionFlags.BlockDwell);
+            BlockDwell = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.BlockDwell) == (ulong)OpenMetaverse.RegionFlags.BlockDwell);
-            AllowLandmark = ((regionFlags & (ulong)RegionFlags.AllowLandmark) == (ulong)RegionFlags.AllowLandmark);
+            AllowLandmark = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.AllowLandmark) == (ulong)OpenMetaverse.RegionFlags.AllowLandmark);
-            AllowParcelChanges = ((regionFlags & (ulong)RegionFlags.AllowParcelChanges) == (ulong)RegionFlags.AllowParcelChanges);
+            AllowParcelChanges = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.AllowParcelChanges) == (ulong)OpenMetaverse.RegionFlags.AllowParcelChanges);
-            AllowSetHome = ((regionFlags & (ulong)RegionFlags.AllowSetHome) == (ulong)RegionFlags.AllowSetHome);
+            AllowSetHome = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.AllowSetHome) == (ulong)OpenMetaverse.RegionFlags.AllowSetHome);
        }
        public bool GroupAccess(UUID groupID)
diff --git a/OpenSim/Framework/GridInstantMessage.cs b/OpenSim/Framework/GridInstantMessage.cs
index a6bf6e3..6ae0488 100644
--- a/OpenSim/Framework/GridInstantMessage.cs
+++ b/OpenSim/Framework/GridInstantMessage.cs
@@ -44,7 +44,6 @@ namespace OpenSim.Framework
        public Vector3 Position;
        public byte[] binaryBucket;
        public uint ParentEstateID;
        public Guid RegionID;
        public uint timestamp;
@@ -58,7 +57,7 @@ namespace OpenSim.Framework
                string _fromAgentName, UUID _toAgentID,
                byte _dialog, bool _fromGroup, string _message,
                UUID _imSessionID, bool _offline, Vector3 _position,
-                byte[] _binaryBucket)
+                byte[] _binaryBucket, bool addTimestamp)
        {
            fromAgentID = _fromAgentID.Guid;
            fromAgentName = _fromAgentName;
@@ -79,7 +78,9 @@ namespace OpenSim.Framework
                ParentEstateID = scene.RegionInfo.EstateSettings.ParentEstateID;
                RegionID = scene.RegionInfo.RegionSettings.RegionUUID.Guid;
            }
-            timestamp = (uint)Util.UnixTimeSinceEpoch();
+            if (addTimestamp)
+                timestamp = (uint)Util.UnixTimeSinceEpoch();
        }
        public GridInstantMessage(IScene scene, UUID _fromAgentID,
@@ -87,7 +88,7 @@ namespace OpenSim.Framework
                string _message, bool _offline,
                Vector3 _position) : this(scene, _fromAgentID, _fromAgentName,
                _toAgentID, _dialog, false, _message,
-                _fromAgentID ^ _toAgentID, _offline, _position, new byte[0])
+                _fromAgentID ^ _toAgentID, _offline, _position, new byte[0], true)
        {
        }
    }
diff --git a/OpenSim/Framework/IClientAPI.cs b/OpenSim/Framework/IClientAPI.cs
index e31c7f6..1c6685a 100644
--- a/OpenSim/Framework/IClientAPI.cs
+++ b/OpenSim/Framework/IClientAPI.cs
@@ -815,8 +815,23 @@ namespace OpenSim.Framework
        event Action<IClientAPI> OnRegionHandShakeReply;
        event GenericCall1 OnRequestWearables;
        event Action<IClientAPI, bool> OnCompleteMovementToRegion;
+        /// <summary>
+        /// Called when an AgentUpdate message is received and before OnAgentUpdate.
+        /// </summary>
+        /// <remarks>
+        /// Listeners must not retain a reference to AgentUpdateArgs since this object may be reused for subsequent AgentUpdates.
+        /// </remarks>
        event UpdateAgent OnPreAgentUpdate;
+        /// <summary>
+        /// Called when an AgentUpdate message is received and after OnPreAgentUpdate.
+        /// </summary>
+        /// <remarks>
+        /// Listeners must not retain a reference to AgentUpdateArgs since this object may be reused for subsequent AgentUpdates.
+        /// </remarks>
        event UpdateAgent OnAgentUpdate;
        event AgentRequestSit OnAgentRequestSit;
        event AgentSit OnAgentSit;
        event AvatarPickerRequest OnAvatarPickerRequest;
@@ -1046,8 +1061,21 @@ namespace OpenSim.Framework
        void InPacket(object NewPack);
        void ProcessInPacket(Packet NewPack);
+        /// <summary>
+        /// Close this client
+        /// </summary>
        void Close();
-        void Close(bool sendStop);
+        /// <summary>
+        /// Close this client
+        /// </summary>
+        /// <param name='force'>
+        /// If true, attempts the close without checking active status.  You do not want to try this except as a last
+        /// ditch attempt where Active == false but the ScenePresence still exists.
+        /// </param>
+        void Close(bool sendStop, bool force);
        void Kick(string message);
        
        /// <summary>
@@ -1084,8 +1112,20 @@ namespace OpenSim.Framework
        void SendAnimations(UUID[] animID, int[] seqs, UUID sourceAgentId, UUID[] objectIDs);
        void SendRegionHandshake(RegionInfo regionInfo, RegionHandshakeArgs args);
-        void SendChatMessage(string message, byte type, Vector3 fromPos, string fromName, UUID fromAgentID, byte source,
+        /// <summary>
-                             byte audible);
+        /// Send chat to the viewer.
+        /// </summary>
+        /// <param name='message'></param>
+        /// <param name='type'></param>
+        /// <param name='fromPos'></param>
+        /// <param name='fromName'></param>
+        /// <param name='fromAgentID'></param>
+        /// <param name='ownerID'></param>
+        /// <param name='source'></param>
+        /// <param name='audible'></param>
+        void SendChatMessage(
+            string message, byte type, Vector3 fromPos, string fromName, UUID fromAgentID, UUID ownerID, byte source,
+            byte audible);
        void SendInstantMessage(GridInstantMessage im);
diff --git a/OpenSim/Framework/InventoryFolderBase.cs b/OpenSim/Framework/InventoryFolderBase.cs
index a12183c..b3457a6 100644
--- a/OpenSim/Framework/InventoryFolderBase.cs
+++ b/OpenSim/Framework/InventoryFolderBase.cs
@@ -73,33 +73,27 @@ namespace OpenSim.Framework
        {
        }
-        public InventoryFolderBase(UUID id)
+        public InventoryFolderBase(UUID id) : this()
        {
            ID = id;
        }
-        public InventoryFolderBase(UUID id, UUID owner)
+        public InventoryFolderBase(UUID id, UUID owner) : this(id)
        {
-            ID = id;
            Owner = owner;
        }
-        public InventoryFolderBase(UUID id, string name, UUID owner, UUID parent)
+        public InventoryFolderBase(UUID id, string name, UUID owner, UUID parent) : this(id, owner)
        {
-            ID = id;
            Name = name;
-            Owner = owner;
            ParentID = parent;
        }
-        public InventoryFolderBase(UUID id, string name, UUID owner, short type, UUID parent, ushort version)
+        public InventoryFolderBase(
+            UUID id, string name, UUID owner, short type, UUID parent, ushort version) : this(id, name, owner, parent)
        {
-            ID = id;
-            Name = name;
-            Owner = owner;
            Type = type;
-            ParentID = parent;
            Version = version;
        }
    }
-}
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/InventoryItemBase.cs b/OpenSim/Framework/InventoryItemBase.cs
index a663680..3d45e76 100644
--- a/OpenSim/Framework/InventoryItemBase.cs
+++ b/OpenSim/Framework/InventoryItemBase.cs
@@ -87,16 +87,7 @@ namespace OpenSim.Framework
        protected string m_creatorId;
        /// <value>
-        /// The UUID for the creator.  This may be different from the canonical CreatorId.  This property is used
+        /// The CreatorId expressed as a UUID.tely
-        /// for communication with the client over the Second Life protocol, since that protocol can only understand
-        /// UUIDs.  As this is a basic framework class, this means that both the string creator id and the uuid
-        /// reference have to be settable separately
-        ///
-        /// Database plugins don't need to set this, it will be set by
-        /// upstream code (or set by the get accessor if left unset).
-        ///
-        /// XXX: An alternative to having a separate uuid property would be to hash the CreatorId appropriately
-        /// every time there was communication with a UUID-only client.  This may be much more expensive.
        /// </value>
        public UUID CreatorIdAsUuid 
        {
@@ -109,20 +100,18 @@ namespace OpenSim.Framework
                return m_creatorIdAsUuid;
            }
-            
-            set
-            {
-                m_creatorIdAsUuid = value;
-            }
        }
        protected UUID m_creatorIdAsUuid = UUID.Zero;
-        protected string m_creatorData = string.Empty;
+        /// <summary>
+        /// Extended creator information of the form <profile url>;<name>
+        /// </summary>
        public string CreatorData // = <profile url>;<name>
        {
            get { return m_creatorData; }
            set { m_creatorData = value; }
        }
+        protected string m_creatorData = string.Empty;
        /// <summary>
        /// Used by the DB layer to retrieve / store the entire user identification.
@@ -162,7 +151,6 @@ namespace OpenSim.Framework
                        name = parts[2];
                    m_creatorData += ';' + name;
                }
            }
        }
diff --git a/OpenSim/Framework/LandData.cs b/OpenSim/Framework/LandData.cs
index dcaa46d..4dffd3f 100644
--- a/OpenSim/Framework/LandData.cs
+++ b/OpenSim/Framework/LandData.cs
@@ -49,8 +49,8 @@ namespace OpenSim.Framework
        // use only one serializer to give the runtime a chance to
        // optimize it (it won't do that if you use a new instance
        // every time)
-        private static XmlSerializer serializer = new XmlSerializer(typeof (LandData));
+        private static XmlSerializer serializer = new XmlSerializer(typeof(LandData));
-        
        private Vector3 _AABBMax = new Vector3();
        private Vector3 _AABBMin = new Vector3();
        private int _area = 0;
@@ -65,11 +65,11 @@ namespace OpenSim.Framework
        private byte[] _bitmap = new byte[512];
        private string _description = String.Empty;
-        private uint _flags = (uint) ParcelFlags.AllowFly | (uint) ParcelFlags.AllowLandmark |
+        private uint _flags = (uint)ParcelFlags.AllowFly | (uint)ParcelFlags.AllowLandmark |
-                                (uint) ParcelFlags.AllowAPrimitiveEntry |
+                                (uint)ParcelFlags.AllowAPrimitiveEntry |
-                                (uint) ParcelFlags.AllowDeedToGroup |
+                                (uint)ParcelFlags.AllowDeedToGroup |
-                                (uint) ParcelFlags.CreateObjects | (uint) ParcelFlags.AllowOtherScripts |
+                                (uint)ParcelFlags.CreateObjects | (uint)ParcelFlags.AllowOtherScripts |
-                                (uint) ParcelFlags.SoundLocal | (uint) ParcelFlags.AllowVoiceChat;
+                                (uint)ParcelFlags.AllowVoiceChat;
        private byte _landingType = 0;
        private string _name = "Your Parcel";
@@ -97,16 +97,36 @@ namespace OpenSim.Framework
        private bool _mediaLoop = false;
        private bool _obscureMusic = false;
        private bool _obscureMedia = false;
+        private float _dwell = 0;
+        /// <summary>
+        /// Traffic count of parcel
+        /// </summary>
+        [XmlIgnore]
+        public float Dwell
+        {
+            get
+            {
+                return _dwell;
+            }
+            set
+            {
+                _dwell = value;
+            }
+        }
        /// <summary>
        /// Whether to obscure parcel media URL
        /// </summary>
        [XmlIgnore]
-        public bool ObscureMedia {
+        public bool ObscureMedia
-            get {
+        {
+            get
+            {
                return _obscureMedia;
            }
-            set {
+            set
+            {
                _obscureMedia = value;
            }
        }
@@ -115,11 +135,14 @@ namespace OpenSim.Framework
        /// Whether to obscure parcel music URL
        /// </summary>
        [XmlIgnore]
-        public bool ObscureMusic {
+        public bool ObscureMusic
-            get {
+        {
+            get
+            {
                return _obscureMusic;
            }
-            set {
+            set
+            {
                _obscureMusic = value;
            }
        }
@@ -128,11 +151,14 @@ namespace OpenSim.Framework
        /// Whether to loop parcel media
        /// </summary>
        [XmlIgnore]
-        public bool MediaLoop {
+        public bool MediaLoop
-            get {
+        {
+            get
+            {
                return _mediaLoop;
            }
-            set {
+            set
+            {
                _mediaLoop = value;
            }
        }
@@ -141,11 +167,14 @@ namespace OpenSim.Framework
        /// Height of parcel media render
        /// </summary>
        [XmlIgnore]
-        public int MediaHeight {
+        public int MediaHeight
-            get {
+        {
+            get
+            {
                return _mediaHeight;
            }
-            set {
+            set
+            {
                _mediaHeight = value;
            }
        }
@@ -154,11 +183,14 @@ namespace OpenSim.Framework
        /// Width of parcel media render
        /// </summary>
        [XmlIgnore]
-        public int MediaWidth {
+        public int MediaWidth
-            get {
+        {
+            get
+            {
                return _mediaWidth;
            }
-            set {
+            set
+            {
                _mediaWidth = value;
            }
        }
@@ -167,11 +199,14 @@ namespace OpenSim.Framework
        /// Upper corner of the AABB for the parcel
        /// </summary>
        [XmlIgnore]
-        public Vector3 AABBMax {
+        public Vector3 AABBMax
-            get {
+        {
+            get
+            {
                return _AABBMax;
            }
-            set {
+            set
+            {
                _AABBMax = value;
            }
        }
@@ -179,11 +214,14 @@ namespace OpenSim.Framework
        /// Lower corner of the AABB for the parcel
        /// </summary>
        [XmlIgnore]
-        public Vector3 AABBMin {
+        public Vector3 AABBMin
-            get {
+        {
+            get
+            {
                return _AABBMin;
            }
-            set {
+            set
+            {
                _AABBMin = value;
            }
        }
@@ -191,11 +229,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Area in meters^2 the parcel contains
        /// </summary>
-        public int Area {
+        public int Area
-            get {
+        {
+            get
+            {
                return _area;
            }
-            set {
+            set
+            {
                _area = value;
            }
        }
@@ -203,11 +244,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// ID of auction (3rd Party Integration) when parcel is being auctioned
        /// </summary>
-        public uint AuctionID {
+        public uint AuctionID
-            get {
+        {
+            get
+            {
                return _auctionID;
            }
-            set {
+            set
+            {
                _auctionID = value;
            }
        }
@@ -215,11 +259,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// UUID of authorized buyer of parcel.  This is UUID.Zero if anyone can buy it.
        /// </summary>
-        public UUID AuthBuyerID {
+        public UUID AuthBuyerID
-            get {
+        {
+            get
+            {
                return _authBuyerID;
            }
-            set {
+            set
+            {
                _authBuyerID = value;
            }
        }
@@ -227,11 +274,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Category of parcel.  Used for classifying the parcel in classified listings
        /// </summary>
-        public ParcelCategory Category {
+        public ParcelCategory Category
-            get {
+        {
+            get
+            {
                return _category;
            }
-            set {
+            set
+            {
                _category = value;
            }
        }
@@ -239,11 +289,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Date that the current owner purchased or claimed the parcel
        /// </summary>
-        public int ClaimDate {
+        public int ClaimDate
-            get {
+        {
+            get
+            {
                return _claimDate;
            }
-            set {
+            set
+            {
                _claimDate = value;
            }
        }
@@ -251,11 +304,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// The last price that the parcel was sold at
        /// </summary>
-        public int ClaimPrice {
+        public int ClaimPrice
-            get {
+        {
+            get
+            {
                return _claimPrice;
            }
-            set {
+            set
+            {
                _claimPrice = value;
            }
        }
@@ -263,11 +319,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Global ID for the parcel.  (3rd Party Integration)
        /// </summary>
-        public UUID GlobalID {
+        public UUID GlobalID
-            get {
+        {
+            get
+            {
                return _globalID;
            }
-            set {
+            set
+            {
                _globalID = value;
            }
        }
@@ -275,11 +334,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Unique ID of the Group that owns
        /// </summary>
-        public UUID GroupID {
+        public UUID GroupID
-            get {
+        {
+            get
+            {
                return _groupID;
            }
-            set {
+            set
+            {
                _groupID = value;
            }
        }
@@ -287,11 +349,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Returns true if the Land Parcel is owned by a group
        /// </summary>
-        public bool IsGroupOwned {
+        public bool IsGroupOwned
-            get {
+        {
+            get
+            {
                return _isGroupOwned;
            }
-            set {
+            set
+            {
                _isGroupOwned = value;
            }
        }
@@ -299,11 +364,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// jp2 data for the image representative of the parcel in the parcel dialog
        /// </summary>
-        public byte[] Bitmap {
+        public byte[] Bitmap
-            get {
+        {
+            get
+            {
                return _bitmap;
            }
-            set {
+            set
+            {
                _bitmap = value;
            }
        }
@@ -311,11 +379,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Parcel Description
        /// </summary>
-        public string Description {
+        public string Description
-            get {
+        {
+            get
+            {
                return _description;
            }
-            set {
+            set
+            {
                _description = value;
            }
        }
@@ -323,11 +394,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Parcel settings.  Access flags, Fly, NoPush, Voice, Scripts allowed, etc.  ParcelFlags
        /// </summary>
-        public uint Flags {
+        public uint Flags
-            get {
+        {
+            get
+            {
                return _flags;
            }
-            set {
+            set
+            {
                _flags = value;
            }
        }
@@ -336,11 +410,14 @@ namespace OpenSim.Framework
        /// Determines if people are able to teleport where they please on the parcel or if they 
        /// get constrainted to a specific point on teleport within the parcel
        /// </summary>
-        public byte LandingType {
+        public byte LandingType
-            get {
+        {
+            get
+            {
                return _landingType;
            }
-            set {
+            set
+            {
                _landingType = value;
            }
        }
@@ -348,11 +425,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Parcel Name
        /// </summary>
-        public string Name {
+        public string Name
-            get {
+        {
+            get
+            {
                return _name;
            }
-            set {
+            set
+            {
                _name = value;
            }
        }
@@ -360,11 +440,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Status of Parcel, Leased, Abandoned, For Sale
        /// </summary>
-        public ParcelStatus Status {
+        public ParcelStatus Status
-            get {
+        {
+            get
+            {
                return _status;
            }
-            set {
+            set
+            {
                _status = value;
            }
        }
@@ -372,11 +455,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Internal ID of the parcel.  Sometimes the client will try to use this value
        /// </summary>
-        public int LocalID {
+        public int LocalID
-            get {
+        {
+            get
+            {
                return _localID;
            }
-            set {
+            set
+            {
                _localID = value;
            }
        }
@@ -384,11 +470,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Determines if we scale the media based on the surface it's on
        /// </summary>
-        public byte MediaAutoScale {
+        public byte MediaAutoScale
-            get {
+        {
+            get
+            {
                return _mediaAutoScale;
            }
-            set {
+            set
+            {
                _mediaAutoScale = value;
            }
        }
@@ -396,11 +485,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Texture Guid to replace with the output of the media stream
        /// </summary>
-        public UUID MediaID {
+        public UUID MediaID
-            get {
+        {
+            get
+            {
                return _mediaID;
            }
-            set {
+            set
+            {
                _mediaID = value;
            }
        }
@@ -408,11 +500,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// URL to the media file to display
        /// </summary>
-        public string MediaURL {
+        public string MediaURL
-            get {
+        {
+            get
+            {
                return _mediaURL;
            }
-            set {
+            set
+            {
                _mediaURL = value;
            }
        }
@@ -432,11 +527,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// URL to the shoutcast music stream to play on the parcel
        /// </summary>
-        public string MusicURL {
+        public string MusicURL
-            get {
+        {
+            get
+            {
                return _musicURL;
            }
-            set {
+            set
+            {
                _musicURL = value;
            }
        }
@@ -445,11 +543,14 @@ namespace OpenSim.Framework
        /// Owner Avatar or Group of the parcel.  Naturally, all land masses must be
        /// owned by someone
        /// </summary>
-        public UUID OwnerID {
+        public UUID OwnerID
-            get {
+        {
+            get
+            {
                return _ownerID;
            }
-            set {
+            set
+            {
                _ownerID = value;
            }
        }
@@ -457,11 +558,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// List of access data for the parcel.  User data, some bitflags, and a time
        /// </summary>
-        public List<LandAccessEntry> ParcelAccessList {
+        public List<LandAccessEntry> ParcelAccessList
-            get {
+        {
+            get
+            {
                return _parcelAccessList;
            }
-            set {
+            set
+            {
                _parcelAccessList = value;
            }
        }
@@ -469,11 +573,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// How long in hours a Pass to the parcel is given
        /// </summary>
-        public float PassHours {
+        public float PassHours
-            get {
+        {
+            get
+            {
                return _passHours;
            }
-            set {
+            set
+            {
                _passHours = value;
            }
        }
@@ -481,11 +588,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// Price to purchase a Pass to a restricted parcel
        /// </summary>
-        public int PassPrice {
+        public int PassPrice
-            get {
+        {
+            get
+            {
                return _passPrice;
            }
-            set {
+            set
+            {
                _passPrice = value;
            }
        }
@@ -493,11 +603,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// When the parcel is being sold, this is the price to purchase the parcel
        /// </summary>
-        public int SalePrice {
+        public int SalePrice
-            get {
+        {
+            get
+            {
                return _salePrice;
            }
-            set {
+            set
+            {
                _salePrice = value;
            }
        }
@@ -506,11 +619,14 @@ namespace OpenSim.Framework
        /// Number of meters^2 in the Simulator
        /// </summary>
        [XmlIgnore]
-        public int SimwideArea {
+        public int SimwideArea
-            get {
+        {
+            get
+            {
                return _simwideArea;
            }
-            set {
+            set
+            {
                _simwideArea = value;
            }
        }
@@ -519,11 +635,14 @@ namespace OpenSim.Framework
        /// Number of SceneObjectPart in the Simulator
        /// </summary>
        [XmlIgnore]
-        public int SimwidePrims {
+        public int SimwidePrims
-            get {
+        {
+            get
+            {
                return _simwidePrims;
            }
-            set {
+            set
+            {
                _simwidePrims = value;
            }
        }
@@ -531,11 +650,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// ID of the snapshot used in the client parcel dialog of the parcel
        /// </summary>
-        public UUID SnapshotID {
+        public UUID SnapshotID
-            get {
+        {
+            get
+            {
                return _snapshotID;
            }
-            set {
+            set
+            {
                _snapshotID = value;
            }
        }
@@ -544,11 +666,14 @@ namespace OpenSim.Framework
        /// When teleporting is restricted to a certain point, this is the location 
        /// that the user will be redirected to
        /// </summary>
-        public Vector3 UserLocation {
+        public Vector3 UserLocation
-            get {
+        {
+            get
+            {
                return _userLocation;
            }
-            set {
+            set
+            {
                _userLocation = value;
            }
        }
@@ -557,11 +682,14 @@ namespace OpenSim.Framework
        /// When teleporting is restricted to a certain point, this is the rotation 
        /// that the user will be positioned
        /// </summary>
-        public Vector3 UserLookAt {
+        public Vector3 UserLookAt
-            get {
+        {
+            get
+            {
                return _userLookAt;
            }
-            set {
+            set
+            {
                _userLookAt = value;
            }
        }
@@ -570,11 +698,14 @@ namespace OpenSim.Framework
        /// Autoreturn number of minutes to return SceneObjectGroup that are owned by someone who doesn't own 
        /// the parcel and isn't set to the same 'group' as the parcel.
        /// </summary>
-        public int OtherCleanTime {
+        public int OtherCleanTime
-            get {
+        {
+            get
+            {
                return _otherCleanTime;
            }
-            set {
+            set
+            {
                _otherCleanTime = value;
            }
        }
@@ -582,11 +713,14 @@ namespace OpenSim.Framework
        /// <summary>
        /// parcel media description
        /// </summary>
-        public string MediaDescription {
+        public string MediaDescription
-            get {
+        {
+            get
+            {
                return _mediaDescription;
            }
-            set {
+            set
+            {
                _mediaDescription = value;
            }
        }
@@ -622,7 +756,7 @@ namespace OpenSim.Framework
            landData._mediaURL = _mediaURL;
            landData._musicURL = _musicURL;
            landData._ownerID = _ownerID;
-            landData._bitmap = (byte[]) _bitmap.Clone();
+            landData._bitmap = (byte[])_bitmap.Clone();
            landData._description = _description;
            landData._flags = _flags;
            landData._name = _name;
@@ -643,6 +777,7 @@ namespace OpenSim.Framework
            landData._obscureMedia = _obscureMedia;
            landData._simwideArea = _simwideArea;
            landData._simwidePrims = _simwidePrims;
+            landData._dwell = _dwell;
            landData._parcelAccessList.Clear();
            foreach (LandAccessEntry entry in _parcelAccessList)
diff --git a/OpenSim/Framework/Monitoring/BaseStatsCollector.cs b/OpenSim/Framework/Monitoring/BaseStatsCollector.cs
index 9ee0876..446e3c0 100644
--- a/OpenSim/Framework/Monitoring/BaseStatsCollector.cs
+++ b/OpenSim/Framework/Monitoring/BaseStatsCollector.cs
@@ -43,27 +43,32 @@ namespace OpenSim.Framework.Monitoring
            StringBuilder sb = new StringBuilder(Environment.NewLine);
            sb.Append("MEMORY STATISTICS");
            sb.Append(Environment.NewLine);
-            sb.Append(
+            sb.AppendFormat(
-                string.Format(
                    "Allocated to OpenSim objects: {0} MB\n",
-                    Math.Round(GC.GetTotalMemory(false) / 1024.0 / 1024.0)));
+                    Math.Round(GC.GetTotalMemory(false) / 1024.0 / 1024.0));
+            sb.AppendFormat(
+                "OpenSim last object memory churn    : {0} MB/s\n",
+                Math.Round((MemoryWatchdog.LastMemoryChurn * 1000) / 1024.0 / 1024, 3));
+            sb.AppendFormat(
+                "OpenSim average object memory churn : {0} MB/s\n",
+                Math.Round((MemoryWatchdog.AverageMemoryChurn * 1000) / 1024.0 / 1024, 3));
            Process myprocess = Process.GetCurrentProcess();
            if (!myprocess.HasExited)
            {
                myprocess.Refresh();
-                sb.Append(
+                sb.AppendFormat(
-                    string.Format(
                        "Process memory:      Physical {0} MB \t Paged {1} MB \t Virtual {2} MB\n",
                        Math.Round(Process.GetCurrentProcess().WorkingSet64 / 1024.0 / 1024.0),
                        Math.Round(Process.GetCurrentProcess().PagedMemorySize64 / 1024.0 / 1024.0),
-                        Math.Round(Process.GetCurrentProcess().VirtualMemorySize64 / 1024.0 / 1024.0)));
+                        Math.Round(Process.GetCurrentProcess().VirtualMemorySize64 / 1024.0 / 1024.0));
-                sb.Append(
+                sb.AppendFormat(
-                    string.Format(
                        "Peak process memory: Physical {0} MB \t Paged {1} MB \t Virtual {2} MB\n",
                        Math.Round(Process.GetCurrentProcess().PeakWorkingSet64 / 1024.0 / 1024.0),
                        Math.Round(Process.GetCurrentProcess().PeakPagedMemorySize64 / 1024.0 / 1024.0),
-                        Math.Round(Process.GetCurrentProcess().PeakVirtualMemorySize64 / 1024.0 / 1024.0)));
+                        Math.Round(Process.GetCurrentProcess().PeakVirtualMemorySize64 / 1024.0 / 1024.0));
            }
            else
                sb.Append("Process reported as Exited \n");
diff --git a/OpenSim/Framework/Monitoring/MemoryWatchdog.cs b/OpenSim/Framework/Monitoring/MemoryWatchdog.cs
index a23cf1f..c6010cd 100644
--- a/OpenSim/Framework/Monitoring/MemoryWatchdog.cs
+++ b/OpenSim/Framework/Monitoring/MemoryWatchdog.cs
@@ -60,7 +60,7 @@ namespace OpenSim.Framework.Monitoring
        private static bool m_enabled;
        /// <summary>
-        /// Average memory churn in bytes per millisecond.
+        /// Last memory churn in bytes per millisecond.
        /// </summary>
        public static double AverageMemoryChurn
        {
@@ -68,6 +68,14 @@ namespace OpenSim.Framework.Monitoring
        }
        /// <summary>
+        /// Average memory churn in bytes per millisecond.
+        /// </summary>
+        public static double LastMemoryChurn
+        {
+            get { if (m_samples.Count > 0) return m_samples.Last(); else return 0; }
+        }
+        /// <summary>
        /// Maximum number of statistical samples.
        /// </summary>
        /// <remarks>
diff --git a/OpenSim/Framework/Monitoring/Properties/AssemblyInfo.cs b/OpenSim/Framework/Monitoring/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..1f2bb40
--- /dev/null
+++ b/OpenSim/Framework/Monitoring/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.Monitoring")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("74506fe3-2f9d-44c1-94c9-a30f79d9e0cb")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/Monitoring/SimExtraStatsCollector.cs b/OpenSim/Framework/Monitoring/SimExtraStatsCollector.cs
index cdd7cc7..aa86202 100644
--- a/OpenSim/Framework/Monitoring/SimExtraStatsCollector.cs
+++ b/OpenSim/Framework/Monitoring/SimExtraStatsCollector.cs
@@ -355,10 +355,25 @@ Asset service request failures: {3}" + Environment.NewLine,
            sb.Append(Environment.NewLine);
            sb.Append(
                string.Format(
-                    "{0,6:0}  {1,6:0}  {2,6:0}  {3,6:0}  {4,6:0}  {5,6:0.0}  {6,6:0.0}  {7,6:0.0}  {8,6:0.0}  {9,6:0.0}  {10,6:0.0}",
+                    "{0,6:0}  {1,6:0}  {2,6:0}  {3,6:0}  {4,6:0}  {5,6:0.0}  {6,6:0.0}  {7,6:0.0}  {8,6:0.0}  {9,6:0.0}  {10,6:0.0}\n\n",
                    inPacketsPerSecond, outPacketsPerSecond, pendingDownloads, pendingUploads, unackedBytes, totalFrameTime,
                    netFrameTime, physicsFrameTime, otherFrameTime, agentFrameTime, imageFrameTime));
-            sb.Append(Environment.NewLine);
+            Dictionary<string, Dictionary<string, Stat>> sceneStats;
+            if (StatsManager.TryGetStats("scene", out sceneStats))
+            {
+                foreach (KeyValuePair<string, Dictionary<string, Stat>> kvp in sceneStats)
+                {
+                    foreach (Stat stat in kvp.Value.Values)
+                    {
+                        if (stat.Verbosity == StatVerbosity.Info)
+                        {
+                            sb.AppendFormat("{0} ({1}): {2}{3}\n", stat.Name, stat.Container, stat.Value, stat.UnitName);
+                        }
+                    }
+                }
+            }
            /*
            sb.Append(Environment.NewLine);
diff --git a/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs b/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs
new file mode 100644
index 0000000..60bed55
--- /dev/null
+++ b/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs
@@ -0,0 +1,88 @@
+/*
+ * 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.Collections.Generic;
+using System.Text;
+namespace OpenSim.Framework.Monitoring
+{
+    public class PercentageStat : Stat
+    {
+        public long Antecedent { get; set; }
+        public long Consequent { get; set; }
+        public override double Value
+        {
+            get
+            {
+                // Asking for an update here means that the updater cannot access this value without infinite recursion.
+                // XXX: A slightly messy but simple solution may be to flick a flag so we can tell if this is being
+                // called by the pull action and just return the value.
+                if (StatType == StatType.Pull)
+                    PullAction(this);
+                long c = Consequent;
+                // Avoid any chance of a multi-threaded divide-by-zero
+                if (c == 0)
+                    return 0;
+                return (double)Antecedent / c * 100;
+            }
+            set
+            {
+                throw new InvalidOperationException("Cannot set value on a PercentageStat");
+            }
+        }
+        public PercentageStat(
+            string shortName,
+            string name,
+            string description,
+            string category,
+            string container,
+            StatType type,
+            Action<Stat> pullAction,
+            StatVerbosity verbosity)
+            : base(shortName, name, description, "%", category, container, type, pullAction, verbosity) {}
+        public override string ToConsoleString()
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendFormat(
+                "{0}.{1}.{2} : {3:0.##}{4} ({5}/{6})",
+                Category, Container, ShortName, Value, UnitName, Antecedent, Consequent);
+            AppendMeasuresOfInterest(sb);
+            return sb.ToString();
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/Monitoring/Stats/Stat.cs b/OpenSim/Framework/Monitoring/Stats/Stat.cs
new file mode 100644
index 0000000..f91251b
--- /dev/null
+++ b/OpenSim/Framework/Monitoring/Stats/Stat.cs
@@ -0,0 +1,238 @@
+/*
+ * 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.Collections.Generic;
+using System.Text;
+namespace OpenSim.Framework.Monitoring
+{
+    /// <summary>
+    /// Holds individual statistic details
+    /// </summary>
+    public class Stat
+    {
+        /// <summary>
+        /// Category of this stat (e.g. cache, scene, etc).
+        /// </summary>
+        public string Category { get; private set; }
+        /// <summary>
+        /// Containing name for this stat.
+        /// FIXME: In the case of a scene, this is currently the scene name (though this leaves
+        /// us with a to-be-resolved problem of non-unique region names).
+        /// </summary>
+        /// <value>
+        /// The container.
+        /// </value>
+        public string Container { get; private set; }
+        public StatType StatType { get; private set; }
+        public MeasuresOfInterest MeasuresOfInterest { get; private set; }
+        /// <summary>
+        /// Action used to update this stat when the value is requested if it's a pull type.
+        /// </summary>
+        public Action<Stat> PullAction { get; private set; }
+        public StatVerbosity Verbosity { get; private set; }
+        public string ShortName { get; private set; }
+        public string Name { get; private set; }
+        public string Description { get; private set; }
+        public virtual string UnitName { get; private set; }
+        public virtual double Value
+        {
+            get
+            {
+                // Asking for an update here means that the updater cannot access this value without infinite recursion.
+                // XXX: A slightly messy but simple solution may be to flick a flag so we can tell if this is being
+                // called by the pull action and just return the value.
+                if (StatType == StatType.Pull)
+                    PullAction(this);
+                return m_value;
+            }
+            set
+            {
+                m_value = value;
+            }
+        }
+        private double m_value;
+        /// <summary>
+        /// Historical samples for calculating measures of interest average.
+        /// </summary>
+        /// <remarks>
+        /// Will be null if no measures of interest require samples.
+        /// </remarks>
+        private static Queue<double> m_samples;
+        /// <summary>
+        /// Maximum number of statistical samples.
+        /// </summary>
+        /// <remarks>
+        /// At the moment this corresponds to 1 minute since the sampling rate is every 2.5 seconds as triggered from
+        /// the main Watchdog.
+        /// </remarks>
+        private static int m_maxSamples = 24;
+        public Stat(
+            string shortName,
+            string name,
+            string description,
+            string unitName,
+            string category,
+            string container,
+            StatType type,
+            Action<Stat> pullAction,
+            StatVerbosity verbosity) 
+                : this(
+                    shortName, 
+                    name, 
+                    description, 
+                    unitName, 
+                    category, 
+                    container, 
+                    type, 
+                    MeasuresOfInterest.None, 
+                    pullAction, 
+                    verbosity)
+        {
+        }
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name='shortName'>Short name for the stat.  Must not contain spaces.  e.g. "LongFrames"</param>
+        /// <param name='name'>Human readable name for the stat.  e.g. "Long frames"</param>
+        /// <param name='description'>Description of stat</param>
+        /// <param name='unitName'>
+        /// Unit name for the stat.  Should be preceeded by a space if the unit name isn't normally appeneded immediately to the value.
+        /// e.g. " frames"
+        /// </param>
+        /// <param name='category'>Category under which this stat should appear, e.g. "scene".  Do not capitalize.</param>
+        /// <param name='container'>Entity to which this stat relates.  e.g. scene name if this is a per scene stat.</param>
+        /// <param name='type'>Push or pull</param>
+        /// <param name='pullAction'>Pull stats need an action to update the stat on request.  Push stats should set null here.</param>
+        /// <param name='moi'>Measures of interest</param>
+        /// <param name='verbosity'>Verbosity of stat.  Controls whether it will appear in short stat display or only full display.</param>
+        public Stat(
+            string shortName,
+            string name,
+            string description,
+            string unitName,
+            string category,
+            string container,
+            StatType type,
+            MeasuresOfInterest moi,
+            Action<Stat> pullAction,
+            StatVerbosity verbosity)
+        {
+            if (StatsManager.SubCommands.Contains(category))
+                throw new Exception(
+                    string.Format("Stat cannot be in category '{0}' since this is reserved for a subcommand", category));
+            ShortName = shortName;
+            Name = name;
+            Description = description;
+            UnitName = unitName;
+            Category = category;
+            Container = container;
+            StatType = type;
+            if (StatType == StatType.Push && pullAction != null)
+                throw new Exception("A push stat cannot have a pull action");
+            else
+                PullAction = pullAction;
+            MeasuresOfInterest = moi;
+            if ((moi & MeasuresOfInterest.AverageChangeOverTime) == MeasuresOfInterest.AverageChangeOverTime)
+                m_samples = new Queue<double>(m_maxSamples);
+            Verbosity = verbosity;
+        }
+        /// <summary>
+        /// Record a value in the sample set.
+        /// </summary>
+        /// <remarks>
+        /// Do not call this if MeasuresOfInterest.None
+        /// </remarks>
+        public void RecordValue()
+        {
+            double newValue = Value;
+            lock (m_samples)
+            {
+                if (m_samples.Count >= m_maxSamples)
+                    m_samples.Dequeue();
+                m_samples.Enqueue(newValue);
+            }
+        }
+        public virtual string ToConsoleString()
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendFormat("{0}.{1}.{2} : {3}{4}", Category, Container, ShortName, Value, UnitName);
+            AppendMeasuresOfInterest(sb);
+            return sb.ToString();
+        }
+        protected void AppendMeasuresOfInterest(StringBuilder sb)
+        {
+            if ((MeasuresOfInterest & MeasuresOfInterest.AverageChangeOverTime) 
+                == MeasuresOfInterest.AverageChangeOverTime)
+            {
+                double totalChange = 0;
+                double? lastSample = null;
+                lock (m_samples)
+                {
+                    foreach (double s in m_samples)
+                    {
+                        if (lastSample != null)
+                            totalChange += s - (double)lastSample;
+                        lastSample = s;
+                    }
+                }
+                int divisor = m_samples.Count <= 1 ? 1 : m_samples.Count - 1;
+                sb.AppendFormat(", {0:0.##}{1}/s", totalChange / divisor / (Watchdog.WATCHDOG_INTERVAL_MS / 1000), UnitName);
+            }
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/Monitoring/StatsManager.cs b/OpenSim/Framework/Monitoring/StatsManager.cs
index d78fa6a..0762b01 100644
--- a/OpenSim/Framework/Monitoring/StatsManager.cs
+++ b/OpenSim/Framework/Monitoring/StatsManager.cs
@@ -25,6 +25,10 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+using System;
+using System.Collections.Generic;
+using System.Text;
 namespace OpenSim.Framework.Monitoring
 {
    /// <summary>
@@ -32,6 +36,24 @@ namespace OpenSim.Framework.Monitoring
    /// </summary>
    public class StatsManager
    {
+        // Subcommand used to list other stats.
+        public const string AllSubCommand = "all";
+        // Subcommand used to list other stats.
+        public const string ListSubCommand = "list";
+        // All subcommands
+        public static HashSet<string> SubCommands = new HashSet<string> { AllSubCommand, ListSubCommand };
+        /// <summary>
+        /// Registered stats categorized by category/container/shortname
+        /// </summary>
+        /// <remarks>
+        /// Do not add or remove directly from this dictionary.
+        /// </remarks>
+        public static Dictionary<string, Dictionary<string, Dictionary<string, Stat>>> RegisteredStats
+            = new Dictionary<string, Dictionary<string, Dictionary<string, Stat>>>();
        private static AssetStatsCollector assetStats;
        private static UserStatsCollector userStats;
        private static SimExtraStatsCollector simExtraStats = new SimExtraStatsCollector();
@@ -40,6 +62,75 @@ namespace OpenSim.Framework.Monitoring
        public static UserStatsCollector UserStats { get { return userStats; } }
        public static SimExtraStatsCollector SimExtraStats { get { return simExtraStats; } }
+        public static void RegisterConsoleCommands(ICommandConsole console)
+        {
+            console.Commands.AddCommand(
+                "General",
+                false,
+                "show stats",
+                "show stats [list|all|<category>]",
+                "Show statistical information for this server",
+                "If no final argument is specified then legacy statistics information is currently shown.\n"
+                    + "If list is specified then statistic categories are shown.\n"
+                    + "If all is specified then all registered statistics are shown.\n"
+                    + "If a category name is specified then only statistics from that category are shown.\n"
+                    + "THIS STATS FACILITY IS EXPERIMENTAL AND DOES NOT YET CONTAIN ALL STATS",
+                HandleShowStatsCommand);
+        }
+        public static void HandleShowStatsCommand(string module, string[] cmd)
+        {
+            ICommandConsole con = MainConsole.Instance;
+            if (cmd.Length > 2)
+            {
+                var categoryName = cmd[2];
+                if (categoryName == AllSubCommand)
+                {
+                    foreach (var category in RegisteredStats.Values)
+                    {
+                        OutputCategoryStatsToConsole(con, category);
+                    }
+                }
+                else if (categoryName == ListSubCommand)
+                {
+                    con.Output("Statistic categories available are:");
+                    foreach (string category in RegisteredStats.Keys)
+                        con.OutputFormat("  {0}", category);
+                }
+                else
+                {
+                    Dictionary<string, Dictionary<string, Stat>> category;
+                    if (!RegisteredStats.TryGetValue(categoryName, out category))
+                    {
+                        con.OutputFormat("No such category as {0}", categoryName);
+                    }
+                    else
+                    {
+                        OutputCategoryStatsToConsole(con, category);
+                    }
+                }
+            }
+            else
+            {
+                // Legacy
+                con.Output(SimExtraStats.Report());
+            }
+        }
+        private static void OutputCategoryStatsToConsole(
+            ICommandConsole con, Dictionary<string, Dictionary<string, Stat>> category)
+        {
+            foreach (var container in category.Values)
+            {
+                foreach (Stat stat in container.Values)
+                {
+                    con.Output(stat.ToConsoleString());
+                }
+            }
+        }
        /// <summary>
        /// Start collecting statistics related to assets.
        /// Should only be called once.
@@ -61,5 +152,153 @@ namespace OpenSim.Framework.Monitoring
            return userStats;
        }
+        /// <summary>
+        /// Registers a statistic.
+        /// </summary>
+        /// <param name='stat'></param>
+        /// <returns></returns>
+        public static bool RegisterStat(Stat stat)
+        {
+            Dictionary<string, Dictionary<string, Stat>> category = null, newCategory;
+            Dictionary<string, Stat> container = null, newContainer;
+            lock (RegisteredStats)
+            {
+                // Stat name is not unique across category/container/shortname key.
+                // XXX: For now just return false.  This is to avoid problems in regression tests where all tests
+                // in a class are run in the same instance of the VM.
+                if (TryGetStat(stat, out category, out container))
+                    return false;
+                // We take a copy-on-write approach here of replacing dictionaries when keys are added or removed.
+                // This means that we don't need to lock or copy them on iteration, which will be a much more
+                // common operation after startup.
+                if (container != null)
+                    newContainer = new Dictionary<string, Stat>(container);
+                else
+                    newContainer = new Dictionary<string, Stat>();
+                if (category != null)
+                    newCategory = new Dictionary<string, Dictionary<string, Stat>>(category);
+                else
+                    newCategory = new Dictionary<string, Dictionary<string, Stat>>();
+                newContainer[stat.ShortName] = stat;
+                newCategory[stat.Container] = newContainer;
+                RegisteredStats[stat.Category] = newCategory;
+            }
+            return true;
+        }
+        /// <summary>
+        /// Deregister a statistic
+        /// </summary>>
+        /// <param name='stat'></param>
+        /// <returns></returns
+        public static bool DeregisterStat(Stat stat)
+        {
+            Dictionary<string, Dictionary<string, Stat>> category = null, newCategory;
+            Dictionary<string, Stat> container = null, newContainer;
+            lock (RegisteredStats)
+            {
+                if (!TryGetStat(stat, out category, out container))
+                    return false;
+                newContainer = new Dictionary<string, Stat>(container);
+                newContainer.Remove(stat.ShortName);
+                newCategory = new Dictionary<string, Dictionary<string, Stat>>(category);
+                newCategory.Remove(stat.Container);
+                newCategory[stat.Container] = newContainer;
+                RegisteredStats[stat.Category] = newCategory;
+                return true;
+            }
+        }
+        public static bool TryGetStats(string category, out Dictionary<string, Dictionary<string, Stat>> stats)
+        {
+            return RegisteredStats.TryGetValue(category, out stats);
+        }
+        public static bool TryGetStat(
+            Stat stat,
+            out Dictionary<string, Dictionary<string, Stat>> category,
+            out Dictionary<string, Stat> container)
+        {
+            category = null;
+            container = null;
+            lock (RegisteredStats)
+            {
+                if (RegisteredStats.TryGetValue(stat.Category, out category))
+                {
+                    if (category.TryGetValue(stat.Container, out container))
+                    {
+                        if (container.ContainsKey(stat.ShortName))
+                            return true;
+                    }
+                }
+            }
+            return false;
+        }
+        public static void RecordStats()
+        {
+            lock (RegisteredStats)
+            {
+                foreach (Dictionary<string, Dictionary<string, Stat>> category in RegisteredStats.Values)
+                {
+                    foreach (Dictionary<string, Stat> container in category.Values)
+                    {
+                        foreach (Stat stat in container.Values)
+                        {
+                            if (stat.MeasuresOfInterest != MeasuresOfInterest.None)
+                                stat.RecordValue();
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /// <summary>
+    /// Stat type.
+    /// </summary>
+    /// <remarks>
+    /// A push stat is one which is continually updated and so it's value can simply by read.
+    /// A pull stat is one where reading the value triggers a collection method - the stat is not continually updated.
+    /// </remarks>
+    public enum StatType
+    {
+        Push,
+        Pull
+    }
+    /// <summary>
+    /// Measures of interest for this stat.
+    /// </summary>
+    [Flags]
+    public enum MeasuresOfInterest
+    {
+        None,
+        AverageChangeOverTime
+    }
+    /// <summary>
+    /// Verbosity of stat.
+    /// </summary>
+    /// <remarks>
+    /// Info will always be displayed.
+    /// </remarks>
+    public enum StatVerbosity
+    {
+        Debug,
+        Info
    }
 }
 \ No newline at end of file
diff --git a/OpenSim/Framework/Monitoring/Watchdog.cs b/OpenSim/Framework/Monitoring/Watchdog.cs
index b709baa..69d2db5 100644
--- a/OpenSim/Framework/Monitoring/Watchdog.cs
+++ b/OpenSim/Framework/Monitoring/Watchdog.cs
@@ -39,7 +39,7 @@ namespace OpenSim.Framework.Monitoring
    public static class Watchdog
    {
        /// <summary>Timer interval in milliseconds for the watchdog timer</summary>
-        const double WATCHDOG_INTERVAL_MS = 2500.0d;
+        public const double WATCHDOG_INTERVAL_MS = 2500.0d;
        /// <summary>Default timeout in milliseconds before a thread is considered dead</summary>
        public const int DEFAULT_WATCHDOG_TIMEOUT_MS = 5000;
@@ -89,6 +89,17 @@ namespace OpenSim.Framework.Monitoring
                FirstTick = Environment.TickCount & Int32.MaxValue;
                LastTick = FirstTick;
            }
+            public ThreadWatchdogInfo(ThreadWatchdogInfo previousTwi)
+            {
+                Thread = previousTwi.Thread;
+                FirstTick = previousTwi.FirstTick;
+                LastTick = previousTwi.LastTick;
+                Timeout = previousTwi.Timeout;
+                IsTimedOut = previousTwi.IsTimedOut;
+                AlarmIfTimeout = previousTwi.AlarmIfTimeout;
+                AlarmMethod = previousTwi.AlarmMethod;
+            }
        }
        /// <summary>
@@ -220,7 +231,25 @@ namespace OpenSim.Framework.Monitoring
        private static bool RemoveThread(int threadID)
        {
            lock (m_threads)
-                return m_threads.Remove(threadID);
+            {
+                ThreadWatchdogInfo twi;
+                if (m_threads.TryGetValue(threadID, out twi))
+                {
+                    m_log.DebugFormat(
+                        "[WATCHDOG]: Removing thread {0}, ID {1}", twi.Thread.Name, twi.Thread.ManagedThreadId);
+                    m_threads.Remove(threadID);
+                    return true;
+                }
+                else
+                {
+                    m_log.WarnFormat(
+                        "[WATCHDOG]: Requested to remove thread with ID {0} but this is not being monitored", threadID);
+                    return false;
+                }
+            }
        }
        public static bool AbortThread(int threadID)
@@ -335,7 +364,9 @@ namespace OpenSim.Framework.Monitoring
                                if (callbackInfos == null)
                                    callbackInfos = new List<ThreadWatchdogInfo>();
-                                callbackInfos.Add(threadInfo);
+                                // Send a copy of the watchdog info to prevent race conditions where the watchdog
+                                // thread updates the monitoring info after an alarm has been sent out.
+                                callbackInfos.Add(new ThreadWatchdogInfo(threadInfo));
                            }
                        }
                    }
@@ -349,6 +380,8 @@ namespace OpenSim.Framework.Monitoring
            if (MemoryWatchdog.Enabled)
                MemoryWatchdog.Update();
+            StatsManager.RecordStats();
            m_watchdogTimer.Start();
        }
    }
diff --git a/OpenSim/Services/InventoryService/InventoryServiceBase.cs b/OpenSim/Framework/Pool.cs
index 456e455..5484f5c 100644
--- a/OpenSim/Services/InventoryService/InventoryServiceBase.cs
+++ b/OpenSim/Framework/Pool.cs
@@ -27,56 +27,65 @@
 using System;
 using System.Collections.Generic;
-using System.Reflection;
-using Nini.Config;
-using OpenSim.Framework;
-using OpenSim.Data;
-using OpenSim.Services.Interfaces;
-using OpenSim.Services.Base;
-namespace OpenSim.Services.InventoryService
+namespace OpenSim.Framework
 {
-    public class InventoryServiceBase : ServiceBase
+    /// <summary>
+    /// Naive pool implementation.
+    /// </summary>
+    /// <remarks>
+    /// Currently assumes that objects are in a useable state when returned.
+    /// </remarks>
+    public class Pool<T>
    {
-        protected IInventoryDataPlugin m_Database = null;
+        /// <summary>
+        /// Number of objects in the pool.
-        public InventoryServiceBase(IConfigSource config) : base(config)
+        /// </summary>
+        public int Count
        {
-            string dllName = String.Empty;
+            get
-            string connString = String.Empty;
-            //
-            // Try reading the [DatabaseService] section first, if it exists
-            //
-            IConfig dbConfig = config.Configs["DatabaseService"];
-            if (dbConfig != null)
            {
-                dllName = dbConfig.GetString("StorageProvider", String.Empty);
+                lock (m_pool)
-                connString = dbConfig.GetString("ConnectionString", String.Empty);
+                    return m_pool.Count;
            }
+        }
-            //
+        private Stack<T> m_pool;
-            // Try reading the more specific [InventoryService] section, if it exists
-            //
-            IConfig inventoryConfig = config.Configs["InventoryService"];
-            if (inventoryConfig != null)
-            {
-                dllName = inventoryConfig.GetString("StorageProvider", dllName);
-                connString = inventoryConfig.GetString("ConnectionString", connString);
-            }
-            //
+        /// <summary>
-            // We tried, but this doesn't exist. We can't proceed.
+        /// Maximum pool size.  Beyond this, any returned objects are not pooled.
-            //
+        /// </summary>
-            if (dllName.Equals(String.Empty))
+        private int m_maxPoolSize;
-                throw new Exception("No InventoryService configuration");
-            m_Database = LoadPlugin<IInventoryDataPlugin>(dllName);
+        private Func<T> m_createFunction;
-            if (m_Database == null)
-                throw new Exception("Could not find a storage interface in the given module");
-            m_Database.Initialise(connString);
+        public Pool(Func<T> createFunction, int maxSize)
+        {
+            m_maxPoolSize = maxSize;
+            m_createFunction = createFunction;
+            m_pool = new Stack<T>(m_maxPoolSize);
        }
+        public T GetObject()
+        {
+            lock (m_pool)
+            {
+                if (m_pool.Count > 0)
+                    return m_pool.Pop();
+                else
+                    return m_createFunction();
+            }
+        }
+        public void ReturnObject(T obj)
+        {
+            lock (m_pool)
+            {
+                if (m_pool.Count >= m_maxPoolSize)
+                    return;
+                else
+                    m_pool.Push(obj);
+            }
+        }
    }
-}
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/RegionFlags.cs b/OpenSim/Framework/RegionFlags.cs
new file mode 100644
index 0000000..a3089b0
--- /dev/null
+++ b/OpenSim/Framework/RegionFlags.cs
@@ -0,0 +1,53 @@
+/*
+ * 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;
+namespace OpenSim.Framework
+{
+    /// <summary>
+    /// Region flags used internally by OpenSimulator to store installation specific information about regions.
+    /// </summary>
+    /// <remarks>
+    /// Don't confuse with OpenMetaverse.RegionFlags which are client facing flags (i.e. they go over the wire).
+    /// Returned by IGridService.GetRegionFlags()
+    /// </remarks>
+    [Flags]
+    public enum RegionFlags : int
+    {
+        DefaultRegion = 1, // Used for new Rez. Random if multiple defined
+        FallbackRegion = 2, // Regions we redirect to when the destination is down
+        RegionOnline = 4, // Set when a region comes online, unset when it unregisters and DeleteOnUnregister is false
+        NoDirectLogin = 8, // Region unavailable for direct logins (by name)
+        Persistent = 16, // Don't remove on unregister
+        LockedOut = 32, // Don't allow registration
+        NoMove = 64, // Don't allow moving this region
+        Reservation = 128, // This is an inactive reservation
+        Authenticate = 256, // Require authentication
+        Hyperlink = 512 // Record represents a HG link
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/RegionInfo.cs b/OpenSim/Framework/RegionInfo.cs
index 4bde7be..e7bed6a 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -122,10 +122,13 @@ namespace OpenSim.Framework
        public UUID lastMapUUID = UUID.Zero;
        public string lastMapRefresh = "0";
+        private float m_nonphysPrimMin = 0;
        private int m_nonphysPrimMax = 0;
+        private float m_physPrimMin = 0;
        private int m_physPrimMax = 0;
        private bool m_clampPrimSize = false;
        private int m_objectCapacity = 0;
+        private int m_linksetCapacity = 0;
        private int m_agentCapacity = 0;
        private string m_regionType = String.Empty;
        private RegionLightShareData m_windlight = new RegionLightShareData();
@@ -287,11 +290,21 @@ namespace OpenSim.Framework
            set { m_windlight = value; }
        }
+        public float NonphysPrimMin
+        {
+            get { return m_nonphysPrimMin; }
+        }
        public int NonphysPrimMax
        {
            get { return m_nonphysPrimMax; }
        }
+        public float PhysPrimMin
+        {
+            get { return m_physPrimMin; }
+        }
        public int PhysPrimMax
        {
            get { return m_physPrimMax; }
@@ -307,6 +320,11 @@ namespace OpenSim.Framework
            get { return m_objectCapacity; }
        }
+        public int LinksetCapacity
+        {
+            get { return m_linksetCapacity; }
+        }
        public int AgentCapacity
        {
            get { return m_agentCapacity; }
@@ -625,16 +643,31 @@ namespace OpenSim.Framework
            m_regionType = config.GetString("RegionType", String.Empty);
            allKeys.Remove("RegionType");
-            // Prim stuff
+            #region Prim stuff
-            //
-            m_nonphysPrimMax = config.GetInt("NonphysicalPrimMax", 0);
+            m_nonphysPrimMin = config.GetFloat("NonPhysicalPrimMin", 0);
-            allKeys.Remove("NonphysicalPrimMax");
+            allKeys.Remove("NonPhysicalPrimMin");
+            m_nonphysPrimMax = config.GetInt("NonPhysicalPrimMax", 0);
+            allKeys.Remove("NonPhysicalPrimMax");
+            m_physPrimMin = config.GetFloat("PhysicalPrimMin", 0);
+            allKeys.Remove("PhysicalPrimMin");
            m_physPrimMax = config.GetInt("PhysicalPrimMax", 0);
            allKeys.Remove("PhysicalPrimMax");
+            
            m_clampPrimSize = config.GetBoolean("ClampPrimSize", false);
            allKeys.Remove("ClampPrimSize");
+            
            m_objectCapacity = config.GetInt("MaxPrims", 15000);
            allKeys.Remove("MaxPrims");
+            m_linksetCapacity = config.GetInt("LinksetPrims", 0);
+            allKeys.Remove("LinksetPrims");
+            
+            #endregion
            m_agentCapacity = config.GetInt("MaxAgents", 100);
            allKeys.Remove("MaxAgents");
@@ -673,16 +706,27 @@ namespace OpenSim.Framework
            config.Set("ExternalHostName", m_externalHostName);
-            if (m_nonphysPrimMax != 0)
+            if (m_nonphysPrimMin > 0)
+                config.Set("NonphysicalPrimMax", m_nonphysPrimMin);
+            if (m_nonphysPrimMax > 0)
                config.Set("NonphysicalPrimMax", m_nonphysPrimMax);
-            if (m_physPrimMax != 0)
+            if (m_physPrimMin > 0)
+                config.Set("PhysicalPrimMax", m_physPrimMin);
+            
+            if (m_physPrimMax > 0)
                config.Set("PhysicalPrimMax", m_physPrimMax);
+                        
            config.Set("ClampPrimSize", m_clampPrimSize.ToString());
-            if (m_objectCapacity != 0)
+            if (m_objectCapacity > 0)
                config.Set("MaxPrims", m_objectCapacity);
-            if (m_agentCapacity != 0)
+            if (m_linksetCapacity > 0)
+                config.Set("LinksetPrims", m_linksetCapacity);
+            if (m_agentCapacity > 0)
                config.Set("MaxAgents", m_agentCapacity);
            if (ScopeID != UUID.Zero)
@@ -759,9 +803,15 @@ namespace OpenSim.Framework
            configMember.addConfigurationOption("lastmap_refresh", ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY,
                                                "Last Map Refresh", Util.UnixTimeSinceEpoch().ToString(), true);
+            configMember.addConfigurationOption("nonphysical_prim_min", ConfigurationOption.ConfigurationTypes.TYPE_FLOAT,
+                                                "Minimum size for nonphysical prims", m_nonphysPrimMin.ToString(), true);
            configMember.addConfigurationOption("nonphysical_prim_max", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
                                                "Maximum size for nonphysical prims", m_nonphysPrimMax.ToString(), true);
+            configMember.addConfigurationOption("physical_prim_min", ConfigurationOption.ConfigurationTypes.TYPE_FLOAT,
+                                                "Minimum size for nonphysical prims", m_physPrimMin.ToString(), true);
            configMember.addConfigurationOption("physical_prim_max", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
                                                "Maximum size for physical prims", m_physPrimMax.ToString(), true);
@@ -771,6 +821,9 @@ namespace OpenSim.Framework
            configMember.addConfigurationOption("object_capacity", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
                                                "Max objects this sim will hold", m_objectCapacity.ToString(), true);
+            configMember.addConfigurationOption("linkset_capacity", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
+                                                "Max prims an object will hold", m_linksetCapacity.ToString(), true);
            configMember.addConfigurationOption("agent_capacity", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
                                                "Max avatars this sim will hold", m_agentCapacity.ToString(), true);
@@ -892,6 +945,9 @@ namespace OpenSim.Framework
                case "object_capacity":
                    m_objectCapacity = (int)configuration_result;
                    break;
+                case "linkset_capacity":
+                    m_linksetCapacity = (int)configuration_result;
+                    break;
                case "agent_capacity":
                    m_agentCapacity = (int)configuration_result;
                    break;
diff --git a/OpenSim/Framework/RegionLoader/Filesystem/Properties/AssemblyInfo.cs b/OpenSim/Framework/RegionLoader/Filesystem/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..d670f2f
--- /dev/null
+++ b/OpenSim/Framework/RegionLoader/Filesystem/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.RegionLoader.Filesystem")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4ab5c74b-e886-40a1-b67d-a04df285e706")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/RegionLoader/Web/Properties/AssemblyInfo.cs b/OpenSim/Framework/RegionLoader/Web/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..7309a12
--- /dev/null
+++ b/OpenSim/Framework/RegionLoader/Web/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.RegionLoader.Web")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("985afff8-e7ed-4056-acce-39abf7a43d33")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/Serialization/ArchiveConstants.cs b/OpenSim/Framework/Serialization/ArchiveConstants.cs
index 2c5e001..48f1c4f 100644
--- a/OpenSim/Framework/Serialization/ArchiveConstants.cs
+++ b/OpenSim/Framework/Serialization/ArchiveConstants.cs
@@ -53,6 +53,11 @@ namespace OpenSim.Framework.Serialization
        public const string INVENTORY_PATH = "inventory/";
        /// <value>
+        /// Path for regions in a multi-region archive
+        /// </value>
+        public const string REGIONS_PATH = "regions/";
+        /// <value>
        /// Path for the prims file
        /// </value>
        public const string OBJECTS_PATH = "objects/";
diff --git a/OpenSim/Framework/Serialization/External/OspResolver.cs b/OpenSim/Framework/Serialization/External/OspResolver.cs
index d31d27c..fa7160f 100644
--- a/OpenSim/Framework/Serialization/External/OspResolver.cs
+++ b/OpenSim/Framework/Serialization/External/OspResolver.cs
@@ -65,9 +65,14 @@ namespace OpenSim.Framework.Serialization
            UserAccount account = userService.GetUserAccount(UUID.Zero, userId);
            if (account != null)
+            {
                return MakeOspa(account.FirstName, account.LastName);
+            }
 //            else
+//            {
 //                m_log.WarnFormat("[OSP RESOLVER]: No user account for {0}", userId);
+//                System.Console.WriteLine("[OSP RESOLVER]: No user account for {0}", userId);
+//            }
            return null;
        }
@@ -79,10 +84,13 @@ namespace OpenSim.Framework.Serialization
        /// <returns></returns>
        public static string MakeOspa(string firstName, string lastName)
        {
-//            m_log.DebugFormat("[OSP RESOLVER]: Making OSPA for {0} {1}", firstName, lastName);
+            string ospa
+                = OSPA_PREFIX + OSPA_NAME_KEY + OSPA_PAIR_SEPARATOR + firstName + OSPA_NAME_VALUE_SEPARATOR + lastName;
+//            m_log.DebugFormat("[OSP RESOLVER]: Made OSPA {0} for {1} {2}", ospa, firstName, lastName);
+//            System.Console.WriteLine("[OSP RESOLVER]: Made OSPA {0} for {1} {2}", ospa, firstName, lastName);
            
-            return 
+            return ospa;
-                OSPA_PREFIX + OSPA_NAME_KEY + OSPA_PAIR_SEPARATOR + firstName + OSPA_NAME_VALUE_SEPARATOR + lastName;
        }
        
        /// <summary>
diff --git a/OpenSim/Framework/Serialization/Properties/AssemblyInfo.cs b/OpenSim/Framework/Serialization/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..11efa4b
--- /dev/null
+++ b/OpenSim/Framework/Serialization/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.Serialization")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("919db41e-4ac0-4f24-9992-81d62c0ee183")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/Servers/BaseOpenSimServer.cs b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
index cf19002..605909d 100644
--- a/OpenSim/Framework/Servers/BaseOpenSimServer.cs
+++ b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
@@ -96,11 +96,6 @@ namespace OpenSim.Framework.Servers
            get { return m_httpServer; }
        }
-        /// <summary>
-        /// Holds the non-viewer statistics collection object for this service/server
-        /// </summary>
-        protected IStatsCollector m_stats;
        public BaseOpenSimServer()
        {
            m_startuptime = DateTime.Now;
@@ -177,10 +172,6 @@ namespace OpenSim.Framework.Servers
                        "show info",
                        "Show general information about the server", HandleShow);
-                m_console.Commands.AddCommand("General", false, "show stats",
-                        "show stats",
-                        "Show statistics", HandleShow);
                m_console.Commands.AddCommand("General", false, "show threads",
                        "show threads",
                        "Show thread status", HandleShow);
@@ -201,8 +192,19 @@ namespace OpenSim.Framework.Servers
                        "threads show",
                        "Show thread status.  Synonym for \"show threads\"",
                        (string module, string[] args) => Notice(GetThreadsReport()));
+                m_console.Commands.AddCommand("General", false, "force gc",
+                        "force gc",
+                        "Manually invoke runtime garbage collection.  For debugging purposes",
+                        HandleForceGc);
            }
        }
+        private void HandleForceGc(string module, string[] args)
+        {
+            MainConsole.Instance.Output("Manually invoking runtime garbage collection");
+            GC.Collect();
+        }
        
        /// <summary>
        /// Should be overriden and referenced by descendents if they need to perform extra shutdown processing
@@ -226,12 +228,7 @@ namespace OpenSim.Framework.Servers
        {
            StringBuilder sb = new StringBuilder("DIAGNOSTICS\n\n");
            sb.Append(GetUptimeReport());
+            sb.Append(StatsManager.SimExtraStats.Report());
-            if (m_stats != null)
-            {
-                sb.Append(m_stats.Report());
-            }
            sb.Append(Environment.NewLine);
            sb.Append(GetThreadsReport());
@@ -382,10 +379,6 @@ namespace OpenSim.Framework.Servers
            {
                Notice("set log level [level] - change the console logging level only.  For example, off or debug.");
                Notice("show info - show server information (e.g. startup path).");
-                if (m_stats != null)
-                    Notice("show stats - show statistical information for this server");
                Notice("show threads - list tracked threads");
                Notice("show uptime - show server startup time and uptime.");
                Notice("show version - show server version.");
@@ -409,11 +402,6 @@ namespace OpenSim.Framework.Servers
                    ShowInfo();
                    break;
-                case "stats":
-                    if (m_stats != null)
-                        Notice(m_stats.Report());
-                    break;
                case "threads":
                    Notice(GetThreadsReport());
                    break;
@@ -604,8 +592,7 @@ namespace OpenSim.Framework.Servers
        
        public string osSecret {
            // Secret uuid for the simulator
-            get { return m_osSecret; }
+            get { return m_osSecret; }            
-            
        }
        public string StatReport(IOSHttpRequest httpRequest)
@@ -613,11 +600,11 @@ namespace OpenSim.Framework.Servers
            // If we catch a request for "callback", wrap the response in the value for jsonp
            if (httpRequest.Query.ContainsKey("callback"))
            {
-                return httpRequest.Query["callback"].ToString() + "(" + m_stats.XReport((DateTime.Now - m_startuptime).ToString() , m_version) + ");";
+                return httpRequest.Query["callback"].ToString() + "(" + StatsManager.SimExtraStats.XReport((DateTime.Now - m_startuptime).ToString() , m_version) + ");";
            } 
            else 
            {
-                return m_stats.XReport((DateTime.Now - m_startuptime).ToString() , m_version); 
+                return StatsManager.SimExtraStats.XReport((DateTime.Now - m_startuptime).ToString() , m_version);
            }
        }
           
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index 788a0b9..3198891 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -54,8 +54,23 @@ namespace OpenSim.Framework.Servers.HttpServer
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private HttpServerLogWriter httpserverlog = new HttpServerLogWriter();
+        /// <summary>
+        /// Gets or sets the debug level.
+        /// </summary>
+        /// <value>
+        /// See MainServer.DebugLevel.
+        /// </value>
        public int DebugLevel { get; set; }
+        /// <summary>
+        /// Request number for diagnostic purposes.
+        /// </summary>
+        /// <remarks>
+        /// This is an internal number.  In some debug situations an external number may also be supplied in the
+        /// opensim-request-id header but we are not currently logging this.
+        /// </remarks>
+        public int RequestNumber { get; private set; }
        private volatile int NotSocketErrors = 0;
        public volatile bool HTTPDRunning = false;
@@ -67,7 +82,7 @@ namespace OpenSim.Framework.Servers.HttpServer
        protected Dictionary<string, LLSDMethod> m_llsdHandlers         = new Dictionary<string, LLSDMethod>();
        protected Dictionary<string, IRequestHandler> m_streamHandlers  = new Dictionary<string, IRequestHandler>();
        protected Dictionary<string, GenericHTTPMethod> m_HTTPHandlers  = new Dictionary<string, GenericHTTPMethod>();
-        protected Dictionary<string, IHttpAgentHandler> m_agentHandlers = new Dictionary<string, IHttpAgentHandler>();
+//        protected Dictionary<string, IHttpAgentHandler> m_agentHandlers = new Dictionary<string, IHttpAgentHandler>();
        protected Dictionary<string, PollServiceEventArgs> m_pollHandlers =
            new Dictionary<string, PollServiceEventArgs>();
@@ -245,29 +260,29 @@ namespace OpenSim.Framework.Servers.HttpServer
                return new List<string>(m_pollHandlers.Keys);
        }
-        // Note that the agent string is provided simply to differentiate
+//        // Note that the agent string is provided simply to differentiate
-        // the handlers - it is NOT required to be an actual agent header
+//        // the handlers - it is NOT required to be an actual agent header
-        // value.
+//        // value.
-        public bool AddAgentHandler(string agent, IHttpAgentHandler handler)
+//        public bool AddAgentHandler(string agent, IHttpAgentHandler handler)
-        {
+//        {
-            lock (m_agentHandlers)
+//            lock (m_agentHandlers)
-            {
+//            {
-                if (!m_agentHandlers.ContainsKey(agent))
+//                if (!m_agentHandlers.ContainsKey(agent))
-                {
+//                {
-                    m_agentHandlers.Add(agent, handler);
+//                    m_agentHandlers.Add(agent, handler);
-                    return true;
+//                    return true;
-                }
+//                }
-            }
+//            }
+//
-            //must already have a handler for that path so return false
+//            //must already have a handler for that path so return false
-            return false;
+//            return false;
-        }
+//        }
+//
-        public List<string> GetAgentHandlerKeys()
+//        public List<string> GetAgentHandlerKeys()
-        {
+//        {
-            lock (m_agentHandlers)
+//            lock (m_agentHandlers)
-                return new List<string>(m_agentHandlers.Keys);
+//                return new List<string>(m_agentHandlers.Keys);
-        }
+//        }
        public bool AddLLSDHandler(string path, LLSDMethod handler)
        {
@@ -296,6 +311,8 @@ namespace OpenSim.Framework.Servers.HttpServer
        private void OnRequest(object source, RequestEventArgs args)
        {
+            RequestNumber++;
            try
            {
                IHttpClientContext context = (IHttpClientContext)source;
@@ -406,7 +423,6 @@ namespace OpenSim.Framework.Servers.HttpServer
            string requestMethod = request.HttpMethod;
            string uriString = request.RawUrl;
-//            string reqnum = "unknown";
            int requestStartTick = Environment.TickCount;
            // Will be adjusted later on.
@@ -423,22 +439,22 @@ namespace OpenSim.Framework.Servers.HttpServer
                Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US", true);
-                //  This is the REST agent interface. We require an agent to properly identify
+//                //  This is the REST agent interface. We require an agent to properly identify
-                //  itself. If the REST handler recognizes the prefix it will attempt to
+//                //  itself. If the REST handler recognizes the prefix it will attempt to
-                //  satisfy the request. If it is not recognizable, and no damage has occurred
+//                //  satisfy the request. If it is not recognizable, and no damage has occurred
-                //  the request can be passed through to the other handlers. This is a low
+//                //  the request can be passed through to the other handlers. This is a low
-                //  probability event; if a request is matched it is normally expected to be
+//                //  probability event; if a request is matched it is normally expected to be
-                //  handled
+//                //  handled
-                IHttpAgentHandler agentHandler;
+//                IHttpAgentHandler agentHandler;
+//
-                if (TryGetAgentHandler(request, response, out agentHandler))
+//                if (TryGetAgentHandler(request, response, out agentHandler))
-                {
+//                {
-                    if (HandleAgentRequest(agentHandler, request, response))
+//                    if (HandleAgentRequest(agentHandler, request, response))
-                    {
+//                    {
-                        requestEndTick = Environment.TickCount;
+//                        requestEndTick = Environment.TickCount;
-                        return;
+//                        return;
-                    }
+//                    }
-                }
+//                }
                //response.KeepAlive = true;
                response.SendChunked = false;
@@ -450,9 +466,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                if (TryGetStreamHandler(handlerKey, out requestHandler))
                {
                    if (DebugLevel >= 3)
-                        m_log.DebugFormat(
+                        LogIncomingToStreamHandler(request, requestHandler);
-                            "[BASE HTTP SERVER]: Found stream handler for {0} {1} {2} {3}",
-                            request.HttpMethod, request.Url.PathAndQuery, requestHandler.Name, requestHandler.Description);
                    response.ContentType = requestHandler.ContentType; // Lets do this defaulting before in case handler has varying content type.
@@ -529,11 +543,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                    {
                        case null:
                        case "text/html":
-    
                            if (DebugLevel >= 3)
-                                m_log.DebugFormat(
+                                LogIncomingToContentTypeHandler(request);
-                                    "[BASE HTTP SERVER]: Found a {0} content type handler for {1} {2}",
-                                    request.ContentType, request.HttpMethod, request.Url.PathAndQuery);
    
                            buffer = HandleHTTPRequest(request, response);
                            break;
@@ -541,11 +552,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                        case "application/llsd+xml":
                        case "application/xml+llsd":
                        case "application/llsd+json":
-    
                            if (DebugLevel >= 3)
-                                m_log.DebugFormat(
+                                LogIncomingToContentTypeHandler(request);
-                                    "[BASE HTTP SERVER]: Found a {0} content type handler for {1} {2}",
-                                    request.ContentType, request.HttpMethod, request.Url.PathAndQuery);
    
                            buffer = HandleLLSDRequests(request, response);
                            break;
@@ -564,9 +572,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                            if (DoWeHaveALLSDHandler(request.RawUrl))
                            {
                                if (DebugLevel >= 3)
-                                    m_log.DebugFormat(
+                                    LogIncomingToContentTypeHandler(request);
-                                        "[BASE HTTP SERVER]: Found a {0} content type handler for {1} {2}",
-                                        request.ContentType, request.HttpMethod, request.Url.PathAndQuery);
    
                                buffer = HandleLLSDRequests(request, response);
                            }
@@ -574,18 +580,14 @@ namespace OpenSim.Framework.Servers.HttpServer
                            else if (DoWeHaveAHTTPHandler(request.RawUrl))
                            {
                                if (DebugLevel >= 3)
-                                    m_log.DebugFormat(
+                                    LogIncomingToContentTypeHandler(request);
-                                        "[BASE HTTP SERVER]: Found a {0} content type handler for {1} {2}",
-                                        request.ContentType, request.HttpMethod, request.Url.PathAndQuery);
    
                                buffer = HandleHTTPRequest(request, response);
                            }
                            else
                            {
                                if (DebugLevel >= 3)
-                                    m_log.DebugFormat(
+                                    LogIncomingToXmlRpcHandler(request);
-                                        "[BASE HTTP SERVER]: Assuming a generic XMLRPC request for {0} {1}",
-                                        request.HttpMethod, request.Url.PathAndQuery);
    
                                // generic login request.
                                buffer = HandleXmlRpcRequests(request, response);
@@ -629,11 +631,11 @@ namespace OpenSim.Framework.Servers.HttpServer
            }
            catch (IOException e)
            {
-                m_log.Error(String.Format("[BASE HTTP SERVER]: HandleRequest() threw {0} ", e.Message), e);
+                m_log.Error(String.Format("[BASE HTTP SERVER]: HandleRequest() threw {0} ", e.StackTrace), e);
            }
            catch (Exception e)
            {
-                m_log.Error(String.Format("[BASE HTTP SERVER]: HandleRequest() threw {0} ", e.Message), e);
+                m_log.Error(String.Format("[BASE HTTP SERVER]: HandleRequest() threw {0} ", e.StackTrace), e);
                SendHTML500(response);
            }
            finally
@@ -644,17 +646,93 @@ namespace OpenSim.Framework.Servers.HttpServer
                if (tickdiff > 3000 && (requestHandler == null || requestHandler.Name == null || requestHandler.Name != "GetTexture"))
                {
                    m_log.InfoFormat(
-                        "[BASE HTTP SERVER]: Slow handling of {0} {1} {2} {3} from {4} took {5}ms",
+                        "[BASE HTTP SERVER]: Slow handling of {0} {1} {2} {3} {4} from {5} took {6}ms",
+                        RequestNumber,
                        requestMethod,
                        uriString,
                        requestHandler != null ? requestHandler.Name : "",
                        requestHandler != null ? requestHandler.Description : "",
-                        request.RemoteIPEndPoint.ToString(),
+                        request.RemoteIPEndPoint,
+                        tickdiff);
+                }
+                else if (DebugLevel >= 4)
+                {
+                    m_log.DebugFormat(
+                        "[BASE HTTP SERVER]: HTTP IN {0} :{1} took {2}ms",
+                        RequestNumber,
+                        Port,
                        tickdiff);
                }
            }
        }
+        private void LogIncomingToStreamHandler(OSHttpRequest request, IRequestHandler requestHandler)
+        {
+            m_log.DebugFormat(
+                "[BASE HTTP SERVER]: HTTP IN {0} :{1} stream handler {2} {3} {4} {5} from {6}",
+                RequestNumber,
+                Port,
+                request.HttpMethod,
+                request.Url.PathAndQuery,
+                requestHandler.Name,
+                requestHandler.Description,
+                request.RemoteIPEndPoint);
+            if (DebugLevel >= 5)
+                LogIncomingInDetail(request);
+        }
+        private void LogIncomingToContentTypeHandler(OSHttpRequest request)
+        {
+            m_log.DebugFormat(
+                "[BASE HTTP SERVER]: HTTP IN {0} :{1} {2} content type handler {3} {4} from {5}",
+                RequestNumber,
+                Port,
+                (request.ContentType == null || request.ContentType == "") ? "not set" : request.ContentType,
+                request.HttpMethod,
+                request.Url.PathAndQuery,
+                request.RemoteIPEndPoint);
+            if (DebugLevel >= 5)
+                LogIncomingInDetail(request);
+        }
+        private void LogIncomingToXmlRpcHandler(OSHttpRequest request)
+        {
+            m_log.DebugFormat(
+                "[BASE HTTP SERVER]: HTTP IN {0} :{1} assumed generic XMLRPC request {2} {3} from {4}",
+                RequestNumber,
+                Port,
+                request.HttpMethod,
+                request.Url.PathAndQuery,
+                request.RemoteIPEndPoint);
+            if (DebugLevel >= 5)
+                LogIncomingInDetail(request);
+        }
+        private void LogIncomingInDetail(OSHttpRequest request)
+        {
+            using (StreamReader reader = new StreamReader(Util.Copy(request.InputStream), Encoding.UTF8))
+            {
+                string output;
+                if (DebugLevel == 5)
+                {
+                    const int sampleLength = 80;
+                    char[] sampleChars = new char[sampleLength];
+                    reader.Read(sampleChars, 0, sampleLength);
+                    output = new string(sampleChars);
+                }
+                else
+                {
+                    output = reader.ReadToEnd();
+                }
+                m_log.DebugFormat("[BASE HTTP SERVER]: {0}...", output.Replace("\n", @"\n"));
+            }
+        }
        private bool TryGetStreamHandler(string handlerKey, out IRequestHandler streamHandler)
        {
            string bestMatch = null;
@@ -747,24 +825,24 @@ namespace OpenSim.Framework.Servers.HttpServer
            }
        }
-        private bool TryGetAgentHandler(OSHttpRequest request, OSHttpResponse response, out IHttpAgentHandler agentHandler)
+//        private bool TryGetAgentHandler(OSHttpRequest request, OSHttpResponse response, out IHttpAgentHandler agentHandler)
-        {
+//        {
-            agentHandler = null;
+//            agentHandler = null;
-            
+//            
-            lock (m_agentHandlers)
+//            lock (m_agentHandlers)
-            {
+//            {
-                foreach (IHttpAgentHandler handler in m_agentHandlers.Values)
+//                foreach (IHttpAgentHandler handler in m_agentHandlers.Values)
-                {
+//                {
-                    if (handler.Match(request, response))
+//                    if (handler.Match(request, response))
-                    {
+//                    {
-                        agentHandler = handler;
+//                        agentHandler = handler;
-                        return true;
+//                        return true;
-                    }
+//                    }
-                }
+//                }
-            }
+//            }
+//
-            return false;
+//            return false;
-        }
+//        }
        /// <summary>
        /// Try all the registered xmlrpc handlers when an xmlrpc request is received.
@@ -1737,21 +1815,21 @@ namespace OpenSim.Framework.Servers.HttpServer
                m_pollHandlers.Remove(path);
        }
-        public bool RemoveAgentHandler(string agent, IHttpAgentHandler handler)
+//        public bool RemoveAgentHandler(string agent, IHttpAgentHandler handler)
-        {
+//        {
-            lock (m_agentHandlers)
+//            lock (m_agentHandlers)
-            {
+//            {
-                IHttpAgentHandler foundHandler;
+//                IHttpAgentHandler foundHandler;
+//
-                if (m_agentHandlers.TryGetValue(agent, out foundHandler) && foundHandler == handler)
+//                if (m_agentHandlers.TryGetValue(agent, out foundHandler) && foundHandler == handler)
-                {
+//                {
-                    m_agentHandlers.Remove(agent);
+//                    m_agentHandlers.Remove(agent);
-                    return true;
+//                    return true;
-                }
+//                }
-            }
+//            }
+//
-            return false;
+//            return false;
-        }
+//        }
        public void RemoveXmlRPCHandler(string method)
        {
diff --git a/OpenSim/Framework/Servers/HttpServer/Interfaces/IHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/Interfaces/IHttpServer.cs
index db58f6f..0bd3aae 100644
--- a/OpenSim/Framework/Servers/HttpServer/Interfaces/IHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/Interfaces/IHttpServer.cs
@@ -41,10 +41,10 @@ namespace OpenSim.Framework.Servers.HttpServer
        uint Port { get; }
        bool UseSSL { get; }
-        // Note that the agent string is provided simply to differentiate
+//        // Note that the agent string is provided simply to differentiate
-        // the handlers - it is NOT required to be an actual agent header
+//        // the handlers - it is NOT required to be an actual agent header
-        // value.
+//        // value.
-        bool AddAgentHandler(string agent, IHttpAgentHandler handler);
+//        bool AddAgentHandler(string agent, IHttpAgentHandler handler);
        
        /// <summary>
        /// Add a handler for an HTTP request.
@@ -106,13 +106,13 @@ namespace OpenSim.Framework.Servers.HttpServer
        bool SetDefaultLLSDHandler(DefaultLLSDMethod handler);
-        /// <summary>
+//        /// <summary>
-        /// Remove the agent if it is registered.
+//        /// Remove the agent if it is registered.
-        /// </summary>
+//        /// </summary>
-        /// <param name="agent"></param>
+//        /// <param name="agent"></param>
-        /// <param name="handler"></param>
+//        /// <param name="handler"></param>
-        /// <returns></returns>
+//        /// <returns></returns>
-        bool RemoveAgentHandler(string agent, IHttpAgentHandler handler);
+//        bool RemoveAgentHandler(string agent, IHttpAgentHandler handler);
        
        /// <summary>
        /// Remove an HTTP handler
diff --git a/OpenSim/Framework/Servers/HttpServer/Properties/AssemblyInfo.cs b/OpenSim/Framework/Servers/HttpServer/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..02ecc25
--- /dev/null
+++ b/OpenSim/Framework/Servers/HttpServer/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.Servers.HttpServer")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("c4ea5baa-81c4-4867-a645-1ec360c1f164")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/Servers/MainServer.cs b/OpenSim/Framework/Servers/MainServer.cs
index 8dc0e3a..ae7d515 100644
--- a/OpenSim/Framework/Servers/MainServer.cs
+++ b/OpenSim/Framework/Servers/MainServer.cs
@@ -29,6 +29,7 @@ using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Net;
+using System.Text;
 using log4net;
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
@@ -47,9 +48,12 @@ namespace OpenSim.Framework.Servers
        /// Control the printing of certain debug messages.
        /// </summary>
        /// <remarks>
-        /// If DebugLevel >= 1, then short warnings are logged when receiving bad input data.
+        /// If DebugLevel >= 1 then short warnings are logged when receiving bad input data.
-        /// If DebugLevel >= 2, then long warnings are logged when receiving bad input data.
+        /// If DebugLevel >= 2 then long warnings are logged when receiving bad input data.
-        /// If DebugLevel >= 3, then short notices about all incoming non-poll HTTP requests are logged.
+        /// If DebugLevel >= 3 then short notices about all incoming non-poll HTTP requests are logged.
+        /// If DebugLevel >= 4 then the time taken to fulfill the request is logged.
+        /// If DebugLevel >= 5 then the start of the body of incoming non-poll HTTP requests will be logged.
+        /// If DebugLevel >= 6 then the entire body of incoming non-poll HTTP requests will be logged.
        /// </remarks>
        public static int DebugLevel
        {
@@ -101,17 +105,28 @@ namespace OpenSim.Framework.Servers
            get { return new Dictionary<uint, BaseHttpServer>(m_Servers); }
        }
        public static void RegisterHttpConsoleCommands(ICommandConsole console)
        {
            console.Commands.AddCommand(
-                "Debug", false, "debug http", "debug http [<level>]",
+                "Comms", false, "show http-handlers",
-                "Turn on inbound non-poll http request debugging.",
+                "show http-handlers",
-                  "If level <= 0, then no extra logging is done.\n"
+                "Show all registered http handlers", HandleShowHttpHandlersCommand);
-                + "If level >= 1, then short warnings are logged when receiving bad input data.\n"
-                + "If level >= 2, then long warnings are logged when receiving bad input data.\n"
+            console.Commands.AddCommand(
-                + "If level >= 3, then short notices about all incoming non-poll HTTP requests are logged.\n"
+                "Debug", false, "debug http", "debug http <in|out|all> [<level>]",
-                + "If no level is specified then the current level is returned.",
+                "Turn on http request logging.",
+                "If in or all and\n"
+                    + "  level <= 0 then no extra logging is done.\n"
+                    + "  level >= 1 then short warnings are logged when receiving bad input data.\n"
+                    + "  level >= 2 then long warnings are logged when receiving bad input data.\n"
+                    + "  level >= 3 then short notices about all incoming non-poll HTTP requests are logged.\n"
+                    + "  level >= 4 then the time taken to fulfill the request is logged.\n"
+                    + "  level >= 5 then a sample from the beginning of the incoming data is logged.\n"
+                    + "  level >= 6 then the entire incoming data is logged.\n"
+                    + "  no level is specified then the current level is returned.\n\n"
+                    + "If out or all and\n"
+                    + "  level >= 3 then short notices about all outgoing requests going through WebUtil are logged.\n"
+                    + "  level >= 4 then the time taken to fulfill the request is logged.\n",
                HandleDebugHttpCommand);
        }
@@ -119,25 +134,120 @@ namespace OpenSim.Framework.Servers
        /// Turn on some debugging values for OpenSim.
        /// </summary>
        /// <param name="args"></param>
-        private static void HandleDebugHttpCommand(string module, string[] args)
+        private static void HandleDebugHttpCommand(string module, string[] cmdparams)
        {
-            if (args.Length == 3)
+            if (cmdparams.Length < 3)
+            {
+                MainConsole.Instance.Output("Usage: debug http <in|out|all> 0..6");
+                return;
+            }
+            bool inReqs = false;
+            bool outReqs = false;
+            bool allReqs = false;
+            string subCommand = cmdparams[2];
+            if (subCommand.ToLower() == "in")
+            {
+                inReqs = true;
+            }
+            else if (subCommand.ToLower() == "out")
+            {
+                outReqs = true;
+            }
+            else if (subCommand.ToLower() == "all")
+            {
+                allReqs = true;
+            }
+            else
            {
+                MainConsole.Instance.Output("You must specify in, out or all");
+                return;
+            }
+            if (cmdparams.Length >= 4)
+            {
+                string rawNewDebug = cmdparams[3];
                int newDebug;
-                if (int.TryParse(args[2], out newDebug))
+                if (!int.TryParse(rawNewDebug, out newDebug))
+                {
+                    MainConsole.Instance.OutputFormat("{0} is not a valid debug level", rawNewDebug);
+                    return;
+                }
+                if (newDebug < 0 || newDebug > 6)
+                {
+                    MainConsole.Instance.OutputFormat("{0} is outside the valid debug level range of 0..6", newDebug);
+                    return;
+                }
+                if (allReqs || inReqs)
                {
                    MainServer.DebugLevel = newDebug;
-                    MainConsole.Instance.OutputFormat("Debug http level set to {0}", newDebug);
+                    MainConsole.Instance.OutputFormat("IN debug level set to {0}", newDebug);
+                }
+                if (allReqs || outReqs)
+                {
+                    WebUtil.DebugLevel = newDebug;
+                    MainConsole.Instance.OutputFormat("OUT debug level set to {0}", newDebug);
                }
            }
-            else if (args.Length == 2)
+            else
            {
-                MainConsole.Instance.OutputFormat("Current debug http level is {0}", MainServer.DebugLevel);
+                if (allReqs || inReqs)
+                    MainConsole.Instance.OutputFormat("Current IN debug level is {0}", MainServer.DebugLevel);
+                if (allReqs || outReqs)
+                    MainConsole.Instance.OutputFormat("Current OUT debug level is {0}", WebUtil.DebugLevel);
            }
-            else
+        }
+        private static void HandleShowHttpHandlersCommand(string module, string[] args)
+        {
+            if (args.Length != 2)
+            {
+                MainConsole.Instance.Output("Usage: show http-handlers");
+                return;
+            }
+            StringBuilder handlers = new StringBuilder();
+            lock (m_Servers)
            {
-                MainConsole.Instance.Output("Usage: debug http 0..3");
+                foreach (BaseHttpServer httpServer in m_Servers.Values)
+                {
+                    handlers.AppendFormat(
+                        "Registered HTTP Handlers for server at {0}:{1}\n", httpServer.ListenIPAddress, httpServer.Port);
+        
+                    handlers.AppendFormat("* XMLRPC:\n");
+                    foreach (String s in httpServer.GetXmlRpcHandlerKeys())
+                        handlers.AppendFormat("\t{0}\n", s);
+        
+                    handlers.AppendFormat("* HTTP:\n");
+                    List<String> poll = httpServer.GetPollServiceHandlerKeys();
+                    foreach (String s in httpServer.GetHTTPHandlerKeys())
+                        handlers.AppendFormat("\t{0} {1}\n", s, (poll.Contains(s) ? "(poll service)" : string.Empty));
+        
+//                    handlers.AppendFormat("* Agent:\n");
+//                    foreach (String s in httpServer.GetAgentHandlerKeys())
+//                        handlers.AppendFormat("\t{0}\n", s);
+        
+                    handlers.AppendFormat("* LLSD:\n");
+                    foreach (String s in httpServer.GetLLSDHandlerKeys())
+                        handlers.AppendFormat("\t{0}\n", s);
+        
+                    handlers.AppendFormat("* StreamHandlers ({0}):\n", httpServer.GetStreamHandlerKeys().Count);
+                    foreach (String s in httpServer.GetStreamHandlerKeys())
+                        handlers.AppendFormat("\t{0}\n", s);
+                    handlers.Append("\n");
+                }
            }
+            MainConsole.Instance.Output(handlers.ToString());
        }
        /// <summary>
diff --git a/OpenSim/Framework/Servers/Properties/AssemblyInfo.cs b/OpenSim/Framework/Servers/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..021f63c
--- /dev/null
+++ b/OpenSim/Framework/Servers/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Framework.Servers")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("b48e8b3e-5c5c-4673-b31f-21e13b8e568b")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Framework/Servers/VersionInfo.cs b/OpenSim/Framework/Servers/VersionInfo.cs
index 016a174..bb094ed 100644
--- a/OpenSim/Framework/Servers/VersionInfo.cs
+++ b/OpenSim/Framework/Servers/VersionInfo.cs
@@ -29,7 +29,7 @@ namespace OpenSim
 {
    public class VersionInfo
    {
-        private const string VERSION_NUMBER = "0.7.4CM";
+        private const string VERSION_NUMBER = "0.7.5CM";
        private const Flavour VERSION_FLAVOUR = Flavour.Dev;
        public enum Flavour
diff --git a/OpenSim/Framework/TaskInventoryDictionary.cs b/OpenSim/Framework/TaskInventoryDictionary.cs
index 4d07746..62ecbd1 100644
--- a/OpenSim/Framework/TaskInventoryDictionary.cs
+++ b/OpenSim/Framework/TaskInventoryDictionary.cs
@@ -39,10 +39,12 @@ using OpenMetaverse;
 namespace OpenSim.Framework
 {
    /// <summary>
-    /// A dictionary for task inventory.
+    /// A dictionary containing task inventory items.  Indexed by item UUID.
    /// </summary>
+    /// <remarks>
    /// This class is not thread safe.  Callers must synchronize on Dictionary methods or Clone() this object before
    /// iterating over it.
+    /// </remarks>
    public class TaskInventoryDictionary : Dictionary<UUID, TaskInventoryItem>,
                                           ICloneable, IXmlSerializable
    {
diff --git a/OpenSim/Framework/TaskInventoryItem.cs b/OpenSim/Framework/TaskInventoryItem.cs
index fb818ee..574ee56 100644
--- a/OpenSim/Framework/TaskInventoryItem.cs
+++ b/OpenSim/Framework/TaskInventoryItem.cs
@@ -73,9 +73,6 @@ namespace OpenSim.Framework
        private bool _ownerChanged = false;
        
-        // This used ONLY during copy. It can't be relied on at other times!
-        private bool _scriptRunning = true;
        public UUID AssetID {
            get {
                return _assetID;
@@ -353,14 +350,13 @@ namespace OpenSim.Framework
            }
        }
-        public bool ScriptRunning {
+        /// <summary>
-            get {
+        /// This used ONLY during copy. It can't be relied on at other times!
-                return _scriptRunning;
+        /// </summary>
-            }
+        /// <remarks>
-            set {
+        /// For true script running status, use IEntityInventory.TryGetScriptInstanceRunning() for now.
-                _scriptRunning = value;
+        /// </remarks>
-            }
+        public bool ScriptRunning { get; set; }
-        }
        // See ICloneable
@@ -388,6 +384,7 @@ namespace OpenSim.Framework
        public TaskInventoryItem()
        {
+            ScriptRunning = true;
            CreationDate = (uint)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;
        }
    }
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 384f716..e76a37b 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -546,6 +546,19 @@ namespace OpenSim.Framework
        }
        /// <summary>
+        /// Determines whether a point is inside a bounding box.
+        /// </summary>
+        /// <param name='v'></param>
+        /// <param name='min'></param>
+        /// <param name='max'></param>
+        /// <returns></returns>
+        public static bool IsInsideBox(Vector3 v, Vector3 min, Vector3 max)
+        {
+            return v.X >= min.X & v.Y >= min.Y && v.Z >= min.Z
+                && v.X <= max.X && v.Y <= max.Y && v.Z <= max.Z;
+        }
+        /// <summary>
        /// Are the co-ordinates of the new region visible from the old region?
        /// </summary>
        /// <param name="oldx">Old region x-coord</param>
@@ -862,6 +875,12 @@ namespace OpenSim.Framework
            return Math.Min(Math.Max(x, min), max);
        }
+        public static Vector3 Clip(Vector3 vec, float min, float max)
+        {
+            return new Vector3(Clip(vec.X, min, max), Clip(vec.Y, min, max),
+                Clip(vec.Z, min, max));
+        }
        /// <summary>
        /// Convert an UUID to a raw uuid string.  Right now this is a string without hyphens.
        /// </summary>
@@ -1013,6 +1032,38 @@ namespace OpenSim.Framework
            }
        }
+        /// <summary>
+        /// Copy data from one stream to another, leaving the read position of both streams at the beginning.
+        /// </summary>
+        /// <param name='inputStream'>
+        /// Input stream.  Must be seekable.
+        /// </param>
+        /// <exception cref='ArgumentException'>
+        /// Thrown if the input stream is not seekable.
+        /// </exception>
+        public static Stream Copy(Stream inputStream)
+        {
+            if (!inputStream.CanSeek)
+                throw new ArgumentException("Util.Copy(Stream inputStream) must receive an inputStream that can seek");
+            const int readSize = 256;
+            byte[] buffer = new byte[readSize];
+            MemoryStream ms = new MemoryStream();
+        
+            int count = inputStream.Read(buffer, 0, readSize);
+            while (count > 0)
+            {
+                ms.Write(buffer, 0, count);
+                count = inputStream.Read(buffer, 0, readSize);
+            }
+            ms.Position = 0;
+            inputStream.Position = 0;
+            return ms;
+        }
        public static XmlRpcResponse XmlRpcCommand(string url, string methodName, params object[] args)
        {
            return SendXmlRpcCommand(url, methodName, args);
diff --git a/OpenSim/Framework/WebUtil.cs b/OpenSim/Framework/WebUtil.cs
index 30a8c28..b85d93d 100644
--- a/OpenSim/Framework/WebUtil.cs
+++ b/OpenSim/Framework/WebUtil.cs
@@ -54,9 +54,17 @@ namespace OpenSim.Framework
                MethodBase.GetCurrentMethod().DeclaringType);
        /// <summary>
+        /// Control the printing of certain debug messages.
+        /// </summary>
+        /// <remarks>
+        /// If DebugLevel >= 3 then short notices about outgoing HTTP requests are logged.
+        /// </remarks>
+        public static int DebugLevel { get; set; }
+        /// <summary>
        /// Request number for diagnostic purposes.
        /// </summary>
-        public static int RequestNumber = 0;
+        public static int RequestNumber { get; internal set; }
        /// <summary>
        /// this is the header field used to communicate the local request id
@@ -146,7 +154,11 @@ namespace OpenSim.Framework
        private static OSDMap ServiceOSDRequestWorker(string url, OSDMap data, string method, int timeout, bool compressed)
        {
            int reqnum = RequestNumber++;
-            // m_log.DebugFormat("[WEB UTIL]: <{0}> start osd request for {1}, method {2}",reqnum,url,method);
+            if (DebugLevel >= 3)
+                m_log.DebugFormat(
+                    "[WEB UTIL]: HTTP OUT {0} ServiceOSD {1} {2} (timeout {3}, compressed {4})",
+                    reqnum, method, url, timeout, compressed);
            string errorMessage = "unknown error";
            int tickstart = Util.EnvironmentTickCount();
@@ -230,7 +242,7 @@ namespace OpenSim.Framework
                int tickdiff = Util.EnvironmentTickCountSubtract(tickstart);
                if (tickdiff > LongCallTime)
                    m_log.InfoFormat(
-                        "[OSD REQUEST]: Slow request to <{0}> {1} {2} took {3}ms, {4}ms writing, {5}",
+                        "[WEB UTIL]: Slow ServiceOSD request {0} {1} {2} took {3}ms, {4}ms writing, {5}",
                        reqnum,
                        method,
                        url,
@@ -239,10 +251,14 @@ namespace OpenSim.Framework
                        strBuffer != null
                            ? (strBuffer.Length > MaxRequestDiagLength ? strBuffer.Remove(MaxRequestDiagLength) : strBuffer)
                            : "");
+                else if (DebugLevel >= 4)
+                    m_log.DebugFormat(
+                        "[WEB UTIL]: HTTP OUT {0} took {1}ms, {2}ms writing",
+                        reqnum, tickdiff, tickdata);
            }
           
            m_log.DebugFormat(
-                "[WEB UTIL]: <{0}> osd request for {1}, method {2} FAILED: {3}", reqnum, url, method, errorMessage);
+                "[WEB UTIL]: ServiceOSD request {0} {1} {2} FAILED: {3}", reqnum, url, method, errorMessage);
            return ErrorResponseMap(errorMessage);
        }
@@ -318,7 +334,11 @@ namespace OpenSim.Framework
        {
            int reqnum = 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);
+            if (DebugLevel >= 3)
+                m_log.DebugFormat(
+                    "[WEB UTIL]: HTTP OUT {0} ServiceForm {1} {2} (timeout {3})",
+                    reqnum, method, url, timeout);
            
            string errorMessage = "unknown error";
            int tickstart = Util.EnvironmentTickCount();
@@ -381,7 +401,7 @@ namespace OpenSim.Framework
                int tickdiff = Util.EnvironmentTickCountSubtract(tickstart);
                if (tickdiff > LongCallTime)
                    m_log.InfoFormat(
-                        "[SERVICE FORM]: Slow request to <{0}> {1} {2} took {3}ms, {4}ms writing, {5}",
+                        "[WEB UTIL]: Slow ServiceForm request {0} {1} {2} took {3}ms, {4}ms writing, {5}",
                        reqnum,
                        method,
                        url,
@@ -390,9 +410,13 @@ namespace OpenSim.Framework
                        queryString != null
                            ? (queryString.Length > MaxRequestDiagLength) ? queryString.Remove(MaxRequestDiagLength) : queryString
                            : "");
+                else if (DebugLevel >= 4)
+                    m_log.DebugFormat(
+                        "[WEB UTIL]: HTTP OUT {0} took {1}ms, {2}ms writing",
+                        reqnum, tickdiff, tickdata);
            }
-            m_log.WarnFormat("[SERVICE FORM]: <{0}> form request to {1} failed: {2}", reqnum, url, errorMessage);
+            m_log.WarnFormat("[WEB UTIL]: ServiceForm request {0} {1} {2} failed: {2}", reqnum, method, url, errorMessage);
            return ErrorResponseMap(errorMessage);
        }
@@ -644,7 +668,6 @@ namespace OpenSim.Framework
        /// <returns></returns>
        public static string[] GetPreferredImageTypes(string accept)
        {
            if (accept == null || accept == string.Empty)
                return new string[0];
@@ -703,14 +726,16 @@ namespace OpenSim.Framework
                int maxConnections)
        {
            int reqnum = WebUtil.RequestNumber++;
-            // m_log.DebugFormat("[WEB UTIL]: <{0}> start osd request for {1}, method {2}",reqnum,url,method);
+            if (WebUtil.DebugLevel >= 3)
+                m_log.DebugFormat(
+                    "[WEB UTIL]: HTTP OUT {0} AsynchronousRequestObject {1} {2}",
+                    reqnum, verb, requestUrl);
            int tickstart = Util.EnvironmentTickCount();
 //            int tickdata = 0;
            int tickdiff = 0;
-//            m_log.DebugFormat("[ASYNC REQUEST]: Starting {0} {1}", verb, requestUrl);
            Type type = typeof(TRequest);
            WebRequest request = WebRequest.Create(requestUrl);
@@ -868,7 +893,7 @@ namespace OpenSim.Framework
                }
                m_log.InfoFormat(
-                    "[ASYNC REQUEST]: Slow request to <{0}> {1} {2} took {3}ms, {4}ms writing, {5}",
+                    "[ASYNC REQUEST]: Slow request {0} {1} {2} took {3}ms, {4}ms writing, {5}",
                    reqnum,
                    verb,
                    requestUrl,
@@ -883,6 +908,12 @@ namespace OpenSim.Framework
                    requestUrl,
                    tickdiff);
            }
+            else if (WebUtil.DebugLevel >= 4)
+            {
+                m_log.DebugFormat(
+                    "[WEB UTIL]: HTTP OUT {0} took {1}ms",
+                    reqnum, tickdiff);
+            }
        }
    }
@@ -903,7 +934,11 @@ namespace OpenSim.Framework
        public static string MakeRequest(string verb, string requestUrl, string obj)
        {
            int reqnum = WebUtil.RequestNumber++;
-            // m_log.DebugFormat("[WEB UTIL]: <{0}> start osd request for {1}, method {2}",reqnum,url,method);
+            if (WebUtil.DebugLevel >= 3)
+                m_log.DebugFormat(
+                    "[WEB UTIL]: HTTP OUT {0} SynchronousRestForms {1} {2}",
+                    reqnum, verb, requestUrl);
            int tickstart = Util.EnvironmentTickCount();
            int tickdata = 0;
@@ -990,7 +1025,7 @@ namespace OpenSim.Framework
            int tickdiff = Util.EnvironmentTickCountSubtract(tickstart);
            if (tickdiff > WebUtil.LongCallTime)
                m_log.InfoFormat(
-                    "[FORMS]: Slow request to <{0}> {1} {2} took {3}ms {4}ms writing {5}",
+                    "[FORMS]: Slow request {0} {1} {2} took {3}ms, {4}ms writing, {5}",
                    reqnum,
                    verb,
                    requestUrl,
@@ -998,6 +1033,10 @@ namespace OpenSim.Framework
                    tickset,
                    tickdata,
                    obj.Length > WebUtil.MaxRequestDiagLength ? obj.Remove(WebUtil.MaxRequestDiagLength) : obj);
+            else if (WebUtil.DebugLevel >= 4)
+                m_log.DebugFormat(
+                    "[WEB UTIL]: HTTP OUT {0} took {1}ms, {2}ms writing",
+                    reqnum, tickdiff, tickdata);
            return respstring;
        }
@@ -1032,7 +1071,11 @@ namespace OpenSim.Framework
        public static TResponse MakeRequest<TRequest, TResponse>(string verb, string requestUrl, TRequest obj, int pTimeout, int maxConnections)
        {
            int reqnum = WebUtil.RequestNumber++;
-            // m_log.DebugFormat("[WEB UTIL]: <{0}> start osd request for {1}, method {2}",reqnum,url,method);
+            if (WebUtil.DebugLevel >= 3)
+                m_log.DebugFormat(
+                    "[WEB UTIL]: HTTP OUT {0} SynchronousRestObject {1} {2}",
+                    reqnum, verb, requestUrl);
            int tickstart = Util.EnvironmentTickCount();
            int tickdata = 0;
@@ -1151,7 +1194,7 @@ namespace OpenSim.Framework
                }
                m_log.InfoFormat(
-                    "[SynchronousRestObjectRequester]: Slow request to <{0}> {1} {2} took {3}ms, {4}ms writing, {5}",
+                    "[SynchronousRestObjectRequester]: Slow request {0} {1} {2} took {3}ms, {4}ms writing, {5}",
                    reqnum,
                    verb,
                    requestUrl,
@@ -1159,6 +1202,12 @@ namespace OpenSim.Framework
                    tickdata,
                    originalRequest);
            }
+            else if (WebUtil.DebugLevel >= 4)
+            {
+                m_log.DebugFormat(
+                    "[WEB UTIL]: HTTP OUT {0} took {1}ms, {2}ms writing",
+                    reqnum, tickdiff, tickdata);
+            }
            return deserial;
        }
diff --git a/OpenSim/Framework/PacketPool.cs b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
index 41d17c5..1fdc410 100644
--- a/OpenSim/Framework/PacketPool.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
@@ -31,63 +31,114 @@ using System.Reflection;
 using OpenMetaverse;
 using OpenMetaverse.Packets;
 using log4net;
+using OpenSim.Framework.Monitoring;
-namespace OpenSim.Framework
+namespace OpenSim.Region.ClientStack.LindenUDP
 {
    public sealed class PacketPool
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private static readonly PacketPool instance = new PacketPool();
-        private bool packetPoolEnabled = true;
+        /// <summary>
-        private bool dataBlockPoolEnabled = true;
+        /// Pool of packets available for reuse.
+        /// </summary>
        private readonly Dictionary<PacketType, Stack<Packet>> pool = new Dictionary<PacketType, Stack<Packet>>();
-        private static Dictionary<Type, Stack<Object>> DataBlocks =
+        private static Dictionary<Type, Stack<Object>> DataBlocks = new Dictionary<Type, Stack<Object>>();
-                new Dictionary<Type, Stack<Object>>();
-        static PacketPool()
+        public static PacketPool Instance
        {
+            get { return instance; }
        }
-        public static PacketPool Instance
+        public bool RecyclePackets { get; set; }
+        public bool RecycleDataBlocks { get; set; }
+        /// <summary>
+        /// The number of packets pooled
+        /// </summary>
+        public int PacketsPooled
        {
-            get { return instance; }
+            get 
+            {
+                lock (pool)
+                    return pool.Count;
+            }
        }
-        public bool RecyclePackets
+        /// <summary>
+        /// The number of blocks pooled.
+        /// </summary>
+        public int BlocksPooled
        {
-            set { packetPoolEnabled = value; }
+            get 
-            get { return packetPoolEnabled; }
+            {
+                lock (DataBlocks) 
+                    return DataBlocks.Count;
+            }
        }
-        public bool RecycleDataBlocks
+        /// <summary>
+        /// Number of packets requested.
+        /// </summary>
+        public long PacketsRequested { get; private set; }
+        /// <summary>
+        /// Number of packets reused.
+        /// </summary>
+        public long PacketsReused { get; private set; }
+        /// <summary>
+        /// Number of packet blocks requested.
+        /// </summary>
+        public long BlocksRequested { get; private set; }
+        /// <summary>
+        /// Number of packet blocks reused.
+        /// </summary>
+        public long BlocksReused { get; private set; }
+        private PacketPool()
        {
-            set { dataBlockPoolEnabled = value; }
+            // defaults
-            get { return dataBlockPoolEnabled; }
+            RecyclePackets = true;
+            RecycleDataBlocks = true;
        }
+        /// <summary>
+        /// Gets a packet of the given type.
+        /// </summary>
+        /// <param name='type'></param>
+        /// <returns>Guaranteed to always return a packet, whether from the pool or newly constructed.</returns>
        public Packet GetPacket(PacketType type)
        {
+            PacketsRequested++;
            Packet packet;
-            if (!packetPoolEnabled)
+            if (!RecyclePackets)
                return Packet.BuildPacket(type);
            lock (pool)
            {
                if (!pool.ContainsKey(type) || pool[type] == null || (pool[type]).Count == 0)
                {
+//                    m_log.DebugFormat("[PACKETPOOL]: Building {0} packet", type);
                    // Creating a new packet if we cannot reuse an old package
                    packet = Packet.BuildPacket(type);
                }
                else
                {
+//                    m_log.DebugFormat("[PACKETPOOL]: Pulling {0} packet", type);
                    // Recycle old packages
-                    packet = (pool[type]).Pop();
+                    PacketsReused++;
+                    packet = pool[type].Pop();
                }
            }
@@ -136,7 +187,7 @@ namespace OpenSim.Framework
        {
            PacketType type = GetType(bytes);
-            Array.Clear(zeroBuffer, 0, zeroBuffer.Length);
+//            Array.Clear(zeroBuffer, 0, zeroBuffer.Length);
            int i = 0;
            Packet packet = GetPacket(type);
@@ -154,7 +205,7 @@ namespace OpenSim.Framework
        /// <param name="packet"></param>
        public void ReturnPacket(Packet packet)
        {
-            if (dataBlockPoolEnabled)
+            if (RecycleDataBlocks)
            {
                switch (packet.Type)
                {
@@ -178,11 +229,12 @@ namespace OpenSim.Framework
                }
            }
-            if (packetPoolEnabled)
+            if (RecyclePackets)
            {
                switch (packet.Type)
                {
                    // List pooling packets here
+                    case PacketType.AgentUpdate:
                    case PacketType.PacketAck:
                    case PacketType.ObjectUpdate:
                    case PacketType.ImprovedTerseObjectUpdate:
@@ -197,7 +249,9 @@ namespace OpenSim.Framework
                            if ((pool[type]).Count < 50)
                            {
-                                (pool[type]).Push(packet);
+//                                m_log.DebugFormat("[PACKETPOOL]: Pushing {0} packet", type);
+                                pool[type].Push(packet);
                            }
                        }
                        break;
@@ -209,16 +263,21 @@ namespace OpenSim.Framework
            }
        }
-        public static T GetDataBlock<T>() where T: new()
+        public T GetDataBlock<T>() where T: new()
        {
            lock (DataBlocks)
            {
+                BlocksRequested++;
                Stack<Object> s;
                if (DataBlocks.TryGetValue(typeof(T), out s))
                {
                    if (s.Count > 0)
+                    {
+                        BlocksReused++;
                        return (T)s.Pop();
+                    }
                }
                else
                {
@@ -229,7 +288,7 @@ namespace OpenSim.Framework
            }
        }
-        public static void ReturnDataBlock<T>(T block) where T: new()
+        public void ReturnDataBlock<T>(T block) where T: new()
        {
            if (block == null)
                return;
@@ -244,4 +303,4 @@ namespace OpenSim.Framework
            }
        }
    }
-}
+}
+\ No newline at end of file