Merge of ubitworkvarnew with opensim/master as of 20150905.

This integrates the OpenSim refactoring to make physics, etc into modules.
AVN physics hasn't been moved to new location.
Does not compile yet.

Merge branch 'osmaster' into mbworknew1

37 files changed, 6948 insertions, 631 deletions

diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
index ed1bab4..eef3c92 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
@@ -35,7 +35,6 @@ using Nini.Config;
 using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs
index 8095b28..1cb4747 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs
@@ -42,7 +42,6 @@ using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Services.Interfaces;
 
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/Tests/GroupsModuleTests.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/Tests/GroupsModuleTests.cs
index e03e71d..9a42bac 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/Tests/GroupsModuleTests.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/Tests/GroupsModuleTests.cs
@@ -37,7 +37,6 @@ using OpenMetaverse.Messages.Linden;
 using OpenMetaverse.Packets;
 using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Region.ClientStack.Linden;
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs
index a040f43..20555e4 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs
@@ -41,7 +41,6 @@ using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Services.Interfaces;
 
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/DataRequestHandler.cs b/OpenSim/Region/OptionalModules/DataSnapshot/DataRequestHandler.cs
new file mode 100644
index 0000000..50276ae
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/DataRequestHandler.cs
@@ -0,0 +1,99 @@
+/*
+* 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.Collections;
+using System.Reflection;
+using System.Xml;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Scenes;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.DataSnapshot
+{
+    public class DataRequestHandler
+    {
+//        private Scene m_scene = null;
+        private DataSnapshotManager m_externalData = null;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public DataRequestHandler(Scene scene, DataSnapshotManager externalData)
+        {
+//            m_scene = scene;
+            m_externalData = externalData;
+
+            //Register HTTP handler
+            if (MainServer.Instance.AddHTTPHandler("collector", OnGetSnapshot))
+            {
+                m_log.Info("[DATASNAPSHOT]: Set up snapshot service");
+            }
+            // Register validation callback handler
+            MainServer.Instance.AddHTTPHandler("validate", OnValidate);
+
+        }
+
+        public Hashtable OnGetSnapshot(Hashtable keysvals)
+        {
+            m_log.Debug("[DATASNAPSHOT] Received collection request");
+            Hashtable reply = new Hashtable();
+            int statuscode = 200;
+
+            string snapObj = (string)keysvals["region"];
+
+            XmlDocument response = m_externalData.GetSnapshot(snapObj);
+
+            reply["str_response_string"] = response.OuterXml;
+            reply["int_response_code"] = statuscode;
+            reply["content_type"] = "text/xml";
+
+            return reply;
+        }
+
+        public Hashtable OnValidate(Hashtable keysvals)
+        {
+            m_log.Debug("[DATASNAPSHOT] Received validation request");
+            Hashtable reply = new Hashtable();
+            int statuscode = 200;
+
+            string secret = (string)keysvals["secret"];
+            if (secret == m_externalData.Secret.ToString())
+                statuscode = 403;
+
+            reply["str_response_string"] = string.Empty;
+            reply["int_response_code"] = statuscode;
+            reply["content_type"] = "text/plain";
+
+            return reply;
+        }
+
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/DataSnapshotManager.cs b/OpenSim/Region/OptionalModules/DataSnapshot/DataSnapshotManager.cs
new file mode 100644
index 0000000..4e766eb
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/DataSnapshotManager.cs
@@ -0,0 +1,486 @@
+/*
+* 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.Net;
+using System.Reflection;
+using System.Text;
+using System.Xml;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using Mono.Addins;
+using OpenSim.Framework;
+using OpenSim.Region.DataSnapshot.Interfaces;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.DataSnapshot
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "DataSnapshotManager")]
+    public class DataSnapshotManager : ISharedRegionModule, IDataSnapshot
+    {
+        #region Class members
+        //Information from config
+        private bool m_enabled = false;
+        private bool m_configLoaded = false;
+        private List<string> m_disabledModules = new List<string>();
+        private Dictionary<string, string> m_gridinfo = new Dictionary<string, string>();
+        private string m_snapsDir = "DataSnapshot";
+        private string m_exposure_level = "minimum";
+
+        //Lists of stuff we need
+        private List<Scene> m_scenes = new List<Scene>();
+        private List<IDataSnapshotProvider> m_dataproviders = new List<IDataSnapshotProvider>();
+
+        //Various internal objects
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        internal object m_syncInit = new object();
+
+        //DataServices and networking
+        private string m_dataServices = "noservices";
+        public string m_listener_port = ConfigSettings.DefaultRegionHttpPort.ToString();
+        public string m_hostname = "127.0.0.1";
+        private UUID m_Secret = UUID.Random();
+        private bool m_servicesNotified = false;
+
+        //Update timers
+        private int m_period = 20; // in seconds
+        private int m_maxStales = 500;
+        private int m_stales = 0;
+        private int m_lastUpdate = 0;
+
+        //Program objects
+        private SnapshotStore m_snapStore = null;
+
+        #endregion
+
+        #region Properties
+
+        public string ExposureLevel
+        {
+            get { return m_exposure_level; }
+        }
+
+        public UUID Secret
+        {
+            get { return m_Secret; }
+        }
+
+        #endregion
+
+        #region Region Module interface
+
+        public void Initialise(IConfigSource config)
+        {
+            if (!m_configLoaded) 
+            {
+                m_configLoaded = true;
+                //m_log.Debug("[DATASNAPSHOT]: Loading configuration");
+                //Read from the config for options
+                lock (m_syncInit)
+                {
+                    try
+                    {
+                        m_enabled = config.Configs["DataSnapshot"].GetBoolean("index_sims", m_enabled);
+                        string gatekeeper = Util.GetConfigVarFromSections<string>(config, "GatekeeperURI",
+                            new string[] { "Startup", "Hypergrid", "GridService" }, String.Empty);
+                        // Legacy. Remove soon!
+                        if (string.IsNullOrEmpty(gatekeeper))
+                        {
+                            IConfig conf = config.Configs["GridService"];
+                            if (conf != null)
+                                gatekeeper = conf.GetString("Gatekeeper", gatekeeper);
+                        }
+                        if (!string.IsNullOrEmpty(gatekeeper))
+                            m_gridinfo.Add("gatekeeperURL", gatekeeper);
+
+                        m_gridinfo.Add(
+                            "name", config.Configs["DataSnapshot"].GetString("gridname", "the lost continent of hippo"));
+                        m_exposure_level = config.Configs["DataSnapshot"].GetString("data_exposure", m_exposure_level);
+                        m_period = config.Configs["DataSnapshot"].GetInt("default_snapshot_period", m_period);
+                        m_maxStales = config.Configs["DataSnapshot"].GetInt("max_changes_before_update", m_maxStales);
+                        m_snapsDir = config.Configs["DataSnapshot"].GetString("snapshot_cache_directory", m_snapsDir);
+                        m_listener_port = config.Configs["Network"].GetString("http_listener_port", m_listener_port);
+
+                        m_dataServices = config.Configs["DataSnapshot"].GetString("data_services", m_dataServices);
+                        // New way of spec'ing data services, one per line
+                        AddDataServicesVars(config.Configs["DataSnapshot"]);
+
+                        String[] annoying_string_array = config.Configs["DataSnapshot"].GetString("disable_modules", "").Split(".".ToCharArray());
+                        foreach (String bloody_wanker in annoying_string_array)
+                        {
+                            m_disabledModules.Add(bloody_wanker);
+                        }
+                        m_lastUpdate = Environment.TickCount;
+                    }
+                    catch (Exception)
+                    {
+                        m_log.Warn("[DATASNAPSHOT]: Could not load configuration. DataSnapshot will be disabled.");
+                        m_enabled = false;
+                        return;
+                    }
+
+                }
+
+            }
+
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_enabled)
+                return;
+
+            m_log.DebugFormat("[DATASNAPSHOT]: Module added to Scene {0}.", scene.RegionInfo.RegionName);
+
+            if (!m_servicesNotified)
+            {
+                m_hostname = scene.RegionInfo.ExternalHostName;
+                m_snapStore = new SnapshotStore(m_snapsDir, m_gridinfo, m_listener_port, m_hostname);
+
+                //Hand it the first scene, assuming that all scenes have the same BaseHTTPServer
+                new DataRequestHandler(scene, this);
+
+                if (m_dataServices != "" && m_dataServices != "noservices")
+                    NotifyDataServices(m_dataServices, "online");
+
+                m_servicesNotified = true;
+            }
+
+            m_scenes.Add(scene);
+            m_snapStore.AddScene(scene);
+
+            Assembly currentasm = Assembly.GetExecutingAssembly();
+
+            foreach (Type pluginType in currentasm.GetTypes())
+            {
+                if (pluginType.IsPublic)
+                {
+                    if (!pluginType.IsAbstract)
+                    {
+                        if (pluginType.GetInterface("IDataSnapshotProvider") != null)
+                        {
+                            IDataSnapshotProvider module = (IDataSnapshotProvider)Activator.CreateInstance(pluginType);
+                            module.Initialize(scene, this);
+                            module.OnStale += MarkDataStale;
+
+                            m_dataproviders.Add(module);
+                            m_snapStore.AddProvider(module);
+
+                            m_log.Debug("[DATASNAPSHOT]: Added new data provider type: " + pluginType.Name);
+                        }
+                    }
+                }
+            }
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_enabled)
+                return;
+
+            m_log.Info("[DATASNAPSHOT]: Region " + scene.RegionInfo.RegionName + " is being removed, removing from indexing");
+            Scene restartedScene = SceneForUUID(scene.RegionInfo.RegionID);
+
+            m_scenes.Remove(restartedScene);
+            m_snapStore.RemoveScene(restartedScene);
+
+            //Getting around the fact that we can't remove objects from a collection we are enumerating over
+            List<IDataSnapshotProvider> providersToRemove = new List<IDataSnapshotProvider>();
+
+            foreach (IDataSnapshotProvider provider in m_dataproviders)
+            {
+                if (provider.GetParentScene == restartedScene)
+                {
+                    providersToRemove.Add(provider);
+                }
+            }
+
+            foreach (IDataSnapshotProvider provider in providersToRemove)
+            {
+                m_dataproviders.Remove(provider);
+                m_snapStore.RemoveProvider(provider);
+            }
+
+            m_snapStore.RemoveScene(restartedScene);
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_enabled)
+                return;
+
+            m_log.DebugFormat("[DATASNAPSHOT]: Marking scene {0} as stale.", scene.RegionInfo.RegionName);
+            m_snapStore.ForceSceneStale(scene);
+        }
+
+        public void Close() 
+        {
+            if (!m_enabled)
+                return;
+
+            if (m_enabled && m_dataServices != "" && m_dataServices != "noservices")
+                NotifyDataServices(m_dataServices, "offline");
+        }
+
+
+        public string Name
+        {
+            get { return "External Data Generator"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        #region Associated helper functions
+
+        public Scene SceneForName(string name)
+        {
+            foreach (Scene scene in m_scenes)
+                if (scene.RegionInfo.RegionName == name)
+                    return scene;
+
+            return null;
+        }
+
+        public Scene SceneForUUID(UUID id)
+        {
+            foreach (Scene scene in m_scenes)
+                if (scene.RegionInfo.RegionID == id)
+                    return scene;
+
+            return null;
+        }
+
+        private void AddDataServicesVars(IConfig config)
+        {
+            // Make sure the services given this way aren't in m_dataServices already
+            List<string> servs = new List<string>(m_dataServices.Split(new char[] { ';' }));
+
+            StringBuilder sb = new StringBuilder();
+            string[] keys = config.GetKeys();
+
+            if (keys.Length > 0)
+            {
+                IEnumerable<string> serviceKeys = keys.Where(value => value.StartsWith("DATA_SRV_"));
+                foreach (string serviceKey in serviceKeys)
+                {
+                    string keyValue = config.GetString(serviceKey, string.Empty).Trim();
+                    if (!servs.Contains(keyValue))
+                        sb.Append(keyValue).Append(";");
+                }
+            }
+
+            m_dataServices = (m_dataServices == "noservices") ? sb.ToString() : sb.Append(m_dataServices).ToString();
+        }
+
+        #endregion
+
+        #region [Public] Snapshot storage functions
+
+        /**
+         * Reply to the http request
+         */
+        public XmlDocument GetSnapshot(string regionName)
+        {
+            CheckStale();
+
+            XmlDocument requestedSnap = new XmlDocument();
+            requestedSnap.AppendChild(requestedSnap.CreateXmlDeclaration("1.0", null, null));
+            requestedSnap.AppendChild(requestedSnap.CreateWhitespace("\r\n"));
+
+            XmlNode regiondata = requestedSnap.CreateNode(XmlNodeType.Element, "regiondata", "");
+            try
+            {
+                if (string.IsNullOrEmpty(regionName))
+                {
+                    XmlNode timerblock = requestedSnap.CreateNode(XmlNodeType.Element, "expire", "");
+                    timerblock.InnerText = m_period.ToString();
+                    regiondata.AppendChild(timerblock);
+
+                    regiondata.AppendChild(requestedSnap.CreateWhitespace("\r\n"));
+                    foreach (Scene scene in m_scenes)
+                    {
+                        regiondata.AppendChild(m_snapStore.GetScene(scene, requestedSnap));
+                    }
+                }
+                else
+                {
+                    Scene scene = SceneForName(regionName);
+                    regiondata.AppendChild(m_snapStore.GetScene(scene, requestedSnap));
+                }
+                requestedSnap.AppendChild(regiondata);
+                regiondata.AppendChild(requestedSnap.CreateWhitespace("\r\n"));
+            }
+            catch (XmlException e)
+            {
+                m_log.Warn("[DATASNAPSHOT]: XmlException while trying to load snapshot: " + e.ToString());
+                requestedSnap = GetErrorMessage(regionName, e);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn("[DATASNAPSHOT]: Caught unknown exception while trying to load snapshot: " + e.StackTrace);
+                requestedSnap = GetErrorMessage(regionName, e);
+            }
+
+
+            return requestedSnap;
+        }
+
+        private XmlDocument GetErrorMessage(string regionName, Exception e)
+        {
+            XmlDocument errorMessage = new XmlDocument();
+            XmlNode error = errorMessage.CreateNode(XmlNodeType.Element, "error", "");
+            XmlNode region = errorMessage.CreateNode(XmlNodeType.Element, "region", "");
+            region.InnerText = regionName;
+
+            XmlNode exception = errorMessage.CreateNode(XmlNodeType.Element, "exception", "");
+            exception.InnerText = e.ToString();
+
+            error.AppendChild(region);
+            error.AppendChild(exception);
+            errorMessage.AppendChild(error);
+
+            return errorMessage;
+        }
+
+        #endregion
+
+        #region External data services
+        private void NotifyDataServices(string servicesStr, string serviceName)
+        {
+            Stream reply = null;
+            string delimStr = ";";
+            char [] delimiter = delimStr.ToCharArray();
+
+            string[] services = servicesStr.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
+
+            for (int i = 0; i < services.Length; i++)
+            {
+                string url = services[i].Trim();
+                using (RestClient cli = new RestClient(url))
+                {
+                    cli.AddQueryParameter("service", serviceName);
+                    cli.AddQueryParameter("host", m_hostname);
+                    cli.AddQueryParameter("port", m_listener_port);
+                    cli.AddQueryParameter("secret", m_Secret.ToString());
+                    cli.RequestMethod = "GET";
+                    try
+                    {
+                        reply = cli.Request(null);
+                    }
+                    catch (WebException)
+                    {
+                        m_log.Warn("[DATASNAPSHOT]: Unable to notify " + url);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Warn("[DATASNAPSHOT]: Ignoring unknown exception " + e.ToString());
+                    }
+
+                    byte[] response = new byte[1024];
+                    // int n = 0;
+                    try
+                    {
+                        // n = reply.Read(response, 0, 1024);
+                        reply.Read(response, 0, 1024);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.WarnFormat("[DATASNAPSHOT]: Unable to decode reply from data service. Ignoring. {0}", e.StackTrace);
+                    }
+                    // This is not quite working, so...
+                    // string responseStr = Util.UTF8.GetString(response);
+                    m_log.Info("[DATASNAPSHOT]: data service " + url + " notified. Secret: " + m_Secret);
+                }
+            }
+        }
+        #endregion
+
+        #region Latency-based update functions
+
+        public void MarkDataStale(IDataSnapshotProvider provider)
+        {
+            //Behavior here: Wait m_period seconds, then update if there has not been a request in m_period seconds
+            //or m_maxStales has been exceeded
+            m_stales++;
+        }
+
+        private void CheckStale()
+        {
+            // Wrap check
+            if (Environment.TickCount < m_lastUpdate)
+            {
+                m_lastUpdate = Environment.TickCount;
+            }
+
+            if (m_stales >= m_maxStales)
+            {
+                if (Environment.TickCount - m_lastUpdate >= 20000)
+                {
+                    m_stales = 0;
+                    m_lastUpdate = Environment.TickCount;
+                    MakeEverythingStale();
+                }
+            }
+            else
+            {
+                if (m_lastUpdate + 1000 * m_period < Environment.TickCount)
+                {
+                    m_stales = 0;
+                    m_lastUpdate = Environment.TickCount;
+                    MakeEverythingStale();
+                }
+            }
+        }
+
+        public void MakeEverythingStale()
+        {
+            m_log.Debug("[DATASNAPSHOT]: Marking all scenes as stale.");
+            foreach (Scene scene in m_scenes)
+            {
+                m_snapStore.ForceSceneStale(scene);
+            }
+        }
+        #endregion
+
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/EstateSnapshot.cs b/OpenSim/Region/OptionalModules/DataSnapshot/EstateSnapshot.cs
new file mode 100644
index 0000000..8da9e8c
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/EstateSnapshot.cs
@@ -0,0 +1,149 @@
+/*
+ * 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.Xml;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+using OpenSim.Region.DataSnapshot.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Region.DataSnapshot.Providers
+{
+    public class EstateSnapshot : IDataSnapshotProvider
+    {
+        /* This module doesn't check for changes, since it's *assumed* there are none.
+         * Nevertheless, it's possible to have changes, since all the fields are public.
+         * There's no event to subscribe to. :/
+         *
+         * I don't think anything changes the fields beyond RegionModule PostInit, however.
+         */
+        private Scene m_scene = null;
+        // private DataSnapshotManager m_parent = null;
+        private bool m_stale = true;
+
+        #region IDataSnapshotProvider Members
+
+        public XmlNode RequestSnapshotData(XmlDocument factory)
+        {
+            //Estate data section - contains who owns a set of sims and the name of the set.
+            //Now in DataSnapshotProvider module form!
+            XmlNode estatedata = factory.CreateNode(XmlNodeType.Element, "estate", "");
+
+            UUID ownerid = m_scene.RegionInfo.EstateSettings.EstateOwner;
+
+            UserAccount userInfo = m_scene.UserAccountService.GetUserAccount(m_scene.RegionInfo.ScopeID, ownerid);
+            //TODO: Change to query userserver about the master avatar UUID ?
+            String firstname;
+            String lastname;
+
+            if (userInfo != null)
+            {
+                firstname = userInfo.FirstName;
+                lastname = userInfo.LastName;
+
+                //TODO: Fix the marshalling system to have less copypasta gruntwork
+                XmlNode user = factory.CreateNode(XmlNodeType.Element, "user", "");
+//                XmlAttribute type = (XmlAttribute)factory.CreateNode(XmlNodeType.Attribute, "type", "");
+//                type.Value = "owner";
+//                user.Attributes.Append(type);
+
+                //TODO: Create more TODOs
+                XmlNode username = factory.CreateNode(XmlNodeType.Element, "name", "");
+                username.InnerText = firstname + " " + lastname;
+                user.AppendChild(username);
+
+                XmlNode useruuid = factory.CreateNode(XmlNodeType.Element, "uuid", "");
+                useruuid.InnerText = ownerid.ToString();
+                user.AppendChild(useruuid);
+
+                estatedata.AppendChild(user);
+            }
+
+            XmlNode estatename = factory.CreateNode(XmlNodeType.Element, "name", "");
+            estatename.InnerText = m_scene.RegionInfo.EstateSettings.EstateName.ToString();
+            estatedata.AppendChild(estatename);
+
+            XmlNode estateid = factory.CreateNode(XmlNodeType.Element, "id", "");
+            estateid.InnerText = m_scene.RegionInfo.EstateSettings.EstateID.ToString();
+            estatedata.AppendChild(estateid);
+
+            XmlNode parentid = factory.CreateNode(XmlNodeType.Element, "parentid", "");
+            parentid.InnerText = m_scene.RegionInfo.EstateSettings.ParentEstateID.ToString();
+            estatedata.AppendChild(parentid);
+
+            XmlNode flags = factory.CreateNode(XmlNodeType.Element, "flags", "");
+
+            XmlAttribute teleport = (XmlAttribute)factory.CreateNode(XmlNodeType.Attribute, "teleport", "");
+            teleport.Value = m_scene.RegionInfo.EstateSettings.AllowDirectTeleport.ToString();
+            flags.Attributes.Append(teleport);
+
+            XmlAttribute publicaccess = (XmlAttribute)factory.CreateNode(XmlNodeType.Attribute, "public", "");
+            publicaccess.Value = m_scene.RegionInfo.EstateSettings.PublicAccess.ToString();
+            flags.Attributes.Append(publicaccess);
+
+            estatedata.AppendChild(flags);
+
+            this.Stale = false;
+            return estatedata;
+        }
+
+        public void Initialize(Scene scene, DataSnapshotManager parent)
+        {
+            m_scene = scene;
+            // m_parent = parent;
+        }
+
+        public Scene GetParentScene
+        {
+            get { return m_scene; }
+        }
+
+        public String Name {
+            get { return "EstateSnapshot"; }
+        }
+
+        public bool Stale
+        {
+            get {
+                return m_stale;
+            }
+            set {
+                m_stale = value;
+
+                if (m_stale)
+                    OnStale(this);
+            }
+        }
+
+        public event ProviderStale OnStale;
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/Interfaces/IDataSnapshot.cs b/OpenSim/Region/OptionalModules/DataSnapshot/Interfaces/IDataSnapshot.cs
new file mode 100644
index 0000000..3b3db65
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/Interfaces/IDataSnapshot.cs
@@ -0,0 +1,36 @@
+/*
+ * 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.Xml;
+
+namespace OpenSim.Region.DataSnapshot.Interfaces
+{
+    public interface IDataSnapshot
+    {
+        XmlDocument GetSnapshot(string regionName);
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/Interfaces/IDataSnapshotProvider.cs b/OpenSim/Region/OptionalModules/DataSnapshot/Interfaces/IDataSnapshotProvider.cs
new file mode 100644
index 0000000..daea373
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/Interfaces/IDataSnapshotProvider.cs
@@ -0,0 +1,46 @@
+/*
+* 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.Xml;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.DataSnapshot.Interfaces
+{
+    public delegate void ProviderStale(IDataSnapshotProvider provider);
+
+    public interface IDataSnapshotProvider
+    {
+        XmlNode RequestSnapshotData(XmlDocument document);
+        void Initialize(Scene scene, DataSnapshotManager parent);
+        Scene GetParentScene { get; }
+        String Name { get; }
+        bool Stale { get; set; }
+        event ProviderStale OnStale;
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/LLSDDiscovery.cs b/OpenSim/Region/OptionalModules/DataSnapshot/LLSDDiscovery.cs
new file mode 100644
index 0000000..54a87f9
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/LLSDDiscovery.cs
@@ -0,0 +1,44 @@
+/*
+* 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 OpenSim.Framework.Capabilities;
+
+namespace OpenSim.Region.DataSnapshot
+{
+    [OSDMap]
+    public class LLSDDiscoveryResponse
+    {
+        public OSDArray snapshot_resources;
+    }
+
+    [OSDMap]
+    public class LLSDDiscoveryDataURL
+    {
+        public string snapshot_format;
+        public string snapshot_url;
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/LandSnapshot.cs b/OpenSim/Region/OptionalModules/DataSnapshot/LandSnapshot.cs
new file mode 100644
index 0000000..b8c90cd
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/LandSnapshot.cs
@@ -0,0 +1,433 @@
+/*
+* 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.Reflection;
+using System.Xml;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+using OpenSim.Region.CoreModules.World.Land;
+using OpenSim.Region.DataSnapshot.Interfaces;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Region.DataSnapshot.Providers
+{
+    public class LandSnapshot : IDataSnapshotProvider
+    {
+        private Scene m_scene = null;
+        private DataSnapshotManager m_parent = null;
+        //private Dictionary<int, Land> m_landIndexed = new Dictionary<int, Land>();
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private bool m_stale = true;
+
+        #region Dead code
+
+        /*
+         * David, I don't think we need this at all. When we do the snapshot, we can
+         * simply look into the parcels that are marked for ShowDirectory -- see
+         * conditional in RequestSnapshotData
+         *
+        //Revise this, look for more direct way of checking for change in land
+        #region Client hooks
+
+        public void OnNewClient(IClientAPI client)
+        {
+            //Land hooks
+            client.OnParcelDivideRequest += ParcelSplitHook;
+            client.OnParcelJoinRequest += ParcelSplitHook;
+            client.OnParcelPropertiesUpdateRequest += ParcelPropsHook;
+        }
+
+        public void ParcelSplitHook(int west, int south, int east, int north, IClientAPI remote_client)
+        {
+            PrepareData();
+        }
+
+        public void ParcelPropsHook(ParcelPropertiesUpdatePacket packet, IClientAPI remote_client)
+        {
+            PrepareData();
+        }
+
+        #endregion
+
+        public void PrepareData()
+        {
+            m_log.Info("[EXTERNALDATA]: Generating land data.");
+
+            m_landIndexed.Clear();
+
+            //Index sim land
+            foreach (KeyValuePair<int, Land> curLand in m_scene.LandManager.landList)
+            {
+                //if ((curLand.Value.LandData.landFlags & (uint)ParcelFlags.ShowDirectory) == (uint)ParcelFlags.ShowDirectory)
+                //{
+                    m_landIndexed.Add(curLand.Key, curLand.Value.Copy());
+                //}
+            }
+        }
+
+        public Dictionary<int,Land> IndexedLand {
+            get { return m_landIndexed; }
+        }
+        */
+
+        #endregion
+
+        #region IDataSnapshotProvider members
+
+        public void Initialize(Scene scene, DataSnapshotManager parent)
+        {
+            m_scene = scene;
+            m_parent = parent;
+
+            //Brought back from the dead for staleness checks.
+            m_scene.EventManager.OnNewClient += OnNewClient;
+        }
+
+        public Scene GetParentScene
+        {
+            get { return m_scene; }
+        }
+
+        public XmlNode RequestSnapshotData(XmlDocument nodeFactory)
+        {
+            ILandChannel landChannel = m_scene.LandChannel;
+            List<ILandObject> parcels = landChannel.AllParcels();
+
+            IDwellModule dwellModule = m_scene.RequestModuleInterface<IDwellModule>();
+
+            XmlNode parent = nodeFactory.CreateNode(XmlNodeType.Element, "parceldata", "");
+            if (parcels != null)
+            {
+
+                //foreach (KeyValuePair<int, Land> curParcel in m_landIndexed)
+                foreach (ILandObject parcel_interface in parcels)
+                {
+                    // Play it safe
+                    if (!(parcel_interface is LandObject))
+                        continue;
+
+                    LandObject land = (LandObject)parcel_interface;
+
+                    LandData parcel = land.LandData;
+                    if (m_parent.ExposureLevel.Equals("all") ||
+                        (m_parent.ExposureLevel.Equals("minimum") && 
+                        (parcel.Flags & (uint)ParcelFlags.ShowDirectory) == (uint)ParcelFlags.ShowDirectory))
+                    {
+
+                        //TODO: make better method of marshalling data from LandData to XmlNode
+                        XmlNode xmlparcel = nodeFactory.CreateNode(XmlNodeType.Element, "parcel", "");
+
+                        // Attributes of the parcel node
+                        XmlAttribute scripts_attr = nodeFactory.CreateAttribute("scripts");
+                        scripts_attr.Value = GetScriptsPermissions(parcel);
+                        XmlAttribute build_attr = nodeFactory.CreateAttribute("build");
+                        build_attr.Value = GetBuildPermissions(parcel);
+                        XmlAttribute public_attr = nodeFactory.CreateAttribute("public");
+                        public_attr.Value = GetPublicPermissions(parcel);
+                        // Check the category of the Parcel
+                        XmlAttribute category_attr = nodeFactory.CreateAttribute("category");
+                        category_attr.Value = ((int)parcel.Category).ToString();
+                        // Check if the parcel is for sale
+                        XmlAttribute forsale_attr = nodeFactory.CreateAttribute("forsale");
+                        forsale_attr.Value = CheckForSale(parcel);
+                        XmlAttribute sales_attr = nodeFactory.CreateAttribute("salesprice");
+                        sales_attr.Value = parcel.SalePrice.ToString();
+
+                        XmlAttribute directory_attr = nodeFactory.CreateAttribute("showinsearch");
+                        directory_attr.Value = GetShowInSearch(parcel);
+                        //XmlAttribute entities_attr = nodeFactory.CreateAttribute("entities");
+                        //entities_attr.Value = land.primsOverMe.Count.ToString();
+                        xmlparcel.Attributes.Append(directory_attr);
+                        xmlparcel.Attributes.Append(scripts_attr);
+                        xmlparcel.Attributes.Append(build_attr);
+                        xmlparcel.Attributes.Append(public_attr);
+                        xmlparcel.Attributes.Append(category_attr);
+                        xmlparcel.Attributes.Append(forsale_attr);
+                        xmlparcel.Attributes.Append(sales_attr);
+                        //xmlparcel.Attributes.Append(entities_attr);
+
+
+                        //name, description, area, and UUID
+                        XmlNode name = nodeFactory.CreateNode(XmlNodeType.Element, "name", "");
+                        name.InnerText = parcel.Name;
+                        xmlparcel.AppendChild(name);
+
+                        XmlNode desc = nodeFactory.CreateNode(XmlNodeType.Element, "description", "");
+                        desc.InnerText = parcel.Description;
+                        xmlparcel.AppendChild(desc);
+
+                        XmlNode uuid = nodeFactory.CreateNode(XmlNodeType.Element, "uuid", "");
+                        uuid.InnerText = parcel.GlobalID.ToString();
+                        xmlparcel.AppendChild(uuid);
+
+                        XmlNode area = nodeFactory.CreateNode(XmlNodeType.Element, "area", "");
+                        area.InnerText = parcel.Area.ToString();
+                        xmlparcel.AppendChild(area);
+
+                        //default location
+                        XmlNode tpLocation = nodeFactory.CreateNode(XmlNodeType.Element, "location", "");
+                        Vector3 loc = parcel.UserLocation;
+                        if (loc.Equals(Vector3.Zero)) // This test is moot at this point: the location is wrong by default
+                            loc = new Vector3((parcel.AABBMax.X + parcel.AABBMin.X) / 2, (parcel.AABBMax.Y + parcel.AABBMin.Y) / 2, (parcel.AABBMax.Z + parcel.AABBMin.Z) / 2);
+                        tpLocation.InnerText = loc.X.ToString() + "/" + loc.Y.ToString() + "/" + loc.Z.ToString();
+                        xmlparcel.AppendChild(tpLocation);
+
+                        XmlNode infouuid = nodeFactory.CreateNode(XmlNodeType.Element, "infouuid", "");
+                        uint x = (uint)loc.X, y = (uint)loc.Y;
+                        findPointInParcel(land, ref x, ref y); // find a suitable spot
+                        infouuid.InnerText = Util.BuildFakeParcelID(
+                                m_scene.RegionInfo.RegionHandle, x, y).ToString();
+                        xmlparcel.AppendChild(infouuid);
+
+                        XmlNode dwell = nodeFactory.CreateNode(XmlNodeType.Element, "dwell", "");
+                        if (dwellModule != null)
+                            dwell.InnerText = dwellModule.GetDwell(parcel.GlobalID).ToString();
+                        else
+                            dwell.InnerText = "0";
+                        xmlparcel.AppendChild(dwell);
+
+                        //TODO: figure how to figure out teleport system landData.landingType
+
+                        //land texture snapshot uuid
+                        if (parcel.SnapshotID != UUID.Zero)
+                        {
+                            XmlNode textureuuid = nodeFactory.CreateNode(XmlNodeType.Element, "image", "");
+                            textureuuid.InnerText = parcel.SnapshotID.ToString();
+                            xmlparcel.AppendChild(textureuuid);
+                        }
+
+                        string groupName = String.Empty;
+
+                        //attached user and group
+                        if (parcel.GroupID != UUID.Zero)
+                        {
+                            XmlNode groupblock = nodeFactory.CreateNode(XmlNodeType.Element, "group", "");
+                            XmlNode groupuuid = nodeFactory.CreateNode(XmlNodeType.Element, "groupuuid", "");
+                            groupuuid.InnerText = parcel.GroupID.ToString();
+                            groupblock.AppendChild(groupuuid);
+
+                            IGroupsModule gm = m_scene.RequestModuleInterface<IGroupsModule>();
+                            if (gm != null)
+                            {
+                                GroupRecord g = gm.GetGroupRecord(parcel.GroupID);
+                                if (g != null)
+                                    groupName = g.GroupName;
+                            }
+
+                            XmlNode groupname = nodeFactory.CreateNode(XmlNodeType.Element, "groupname", "");
+                            groupname.InnerText = groupName;
+                            groupblock.AppendChild(groupname);
+
+                            xmlparcel.AppendChild(groupblock);
+                        }
+
+                        XmlNode userblock = nodeFactory.CreateNode(XmlNodeType.Element, "owner", "");
+
+                        UUID userOwnerUUID = parcel.OwnerID;
+
+                        XmlNode useruuid = nodeFactory.CreateNode(XmlNodeType.Element, "uuid", "");
+                        useruuid.InnerText = userOwnerUUID.ToString();
+                        userblock.AppendChild(useruuid);
+
+                        if (!parcel.IsGroupOwned)
+                        {
+                            try
+                            {
+                                XmlNode username = nodeFactory.CreateNode(XmlNodeType.Element, "name", "");
+                                UserAccount account = m_scene.UserAccountService.GetUserAccount(m_scene.RegionInfo.ScopeID, userOwnerUUID);
+                                username.InnerText = account.FirstName + " " + account.LastName;
+                                userblock.AppendChild(username);
+                            }
+                            catch (Exception)
+                            {
+                                //m_log.Info("[DATASNAPSHOT]: Cannot find owner name; ignoring this parcel");
+                            }
+
+                        }
+                        else
+                        {
+                            XmlNode username = nodeFactory.CreateNode(XmlNodeType.Element, "name", "");
+                            username.InnerText = groupName;
+                            userblock.AppendChild(username);
+                        }
+
+                        xmlparcel.AppendChild(userblock);
+
+                        parent.AppendChild(xmlparcel);
+                    }
+                }
+                //snap.AppendChild(parent);
+            }
+
+            this.Stale = false;
+            return parent;
+        }
+
+        public String Name
+        {
+            get { return "LandSnapshot"; }
+        }
+
+        public bool Stale
+        {
+            get
+            {
+                return m_stale;
+            }
+            set
+            {
+                m_stale = value;
+
+                if (m_stale)
+                    OnStale(this);
+            }
+        }
+
+        public event ProviderStale OnStale;
+
+        #endregion
+
+        #region Helper functions
+
+        private string GetScriptsPermissions(LandData parcel)
+        {
+            if ((parcel.Flags & (uint)ParcelFlags.AllowOtherScripts) == (uint)ParcelFlags.AllowOtherScripts)
+                return "true";
+            else
+                return "false";
+
+        }
+
+        private string GetPublicPermissions(LandData parcel)
+        {
+            if ((parcel.Flags & (uint)ParcelFlags.UseAccessList) == (uint)ParcelFlags.UseAccessList)
+                return "false";
+            else
+                return "true";
+
+        }
+
+        private string GetBuildPermissions(LandData parcel)
+        {
+            if ((parcel.Flags & (uint)ParcelFlags.CreateObjects) == (uint)ParcelFlags.CreateObjects)
+                return "true";
+            else
+                return "false";
+
+        }
+
+        private string CheckForSale(LandData parcel)
+        {
+            if ((parcel.Flags & (uint)ParcelFlags.ForSale) == (uint)ParcelFlags.ForSale)
+                return "true";
+            else
+                return "false";
+        }
+
+        private string GetShowInSearch(LandData parcel)
+        {
+            if ((parcel.Flags & (uint)ParcelFlags.ShowDirectory) == (uint)ParcelFlags.ShowDirectory)
+                return "true";
+            else
+                return "false";
+
+        }
+
+        #endregion
+
+        #region Change detection hooks
+
+        public void OnNewClient(IClientAPI client)
+        {
+            //Land hooks
+            client.OnParcelDivideRequest += delegate(int west, int south, int east, int north,
+                IClientAPI remote_client) { this.Stale = true; };
+            client.OnParcelJoinRequest += delegate(int west, int south, int east, int north,
+                IClientAPI remote_client) { this.Stale = true; };
+            client.OnParcelPropertiesUpdateRequest += delegate(LandUpdateArgs args, int local_id,
+                IClientAPI remote_client) { this.Stale = true; };
+            client.OnParcelBuy += delegate(UUID agentId, UUID groupId, bool final, bool groupOwned,
+                bool removeContribution, int parcelLocalID, int parcelArea, int parcelPrice, bool authenticated)
+            { this.Stale = true; };
+        }
+
+        public void ParcelSplitHook(int west, int south, int east, int north, IClientAPI remote_client)
+        {
+            this.Stale = true;
+        }
+
+        public void ParcelPropsHook(LandUpdateArgs args, int local_id, IClientAPI remote_client)
+        {
+            this.Stale = true;
+        }
+
+        #endregion
+
+        // this is needed for non-convex parcels (example: rectangular parcel, and in the exact center
+        // another, smaller rectangular parcel). Both will have the same initial coordinates.
+        private void findPointInParcel(ILandObject land, ref uint refX, ref uint refY)
+        {
+            m_log.DebugFormat("[DATASNAPSHOT] trying {0}, {1}", refX, refY);
+            // the point we started with already is in the parcel
+            if (land.ContainsPoint((int)refX, (int)refY)) return;
+
+            // ... otherwise, we have to search for a point within the parcel
+            uint startX = (uint)land.LandData.AABBMin.X;
+            uint startY = (uint)land.LandData.AABBMin.Y;
+            uint endX = (uint)land.LandData.AABBMax.X;
+            uint endY = (uint)land.LandData.AABBMax.Y;
+
+            // default: center of the parcel
+            refX = (startX + endX) / 2;
+            refY = (startY + endY) / 2;
+            // If the center point is within the parcel, take that one
+            if (land.ContainsPoint((int)refX, (int)refY)) return;
+
+            // otherwise, go the long way.
+            for (uint y = startY; y <= endY; ++y)
+            {
+                for (uint x = startX; x <= endX; ++x)
+                {
+                    if (land.ContainsPoint((int)x, (int)y))
+                    {
+                        // found a point
+                        refX = x;
+                        refY = y;
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/ObjectSnapshot.cs b/OpenSim/Region/OptionalModules/DataSnapshot/ObjectSnapshot.cs
new file mode 100644
index 0000000..0bb4044
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/ObjectSnapshot.cs
@@ -0,0 +1,264 @@
+/*
+ * 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.Reflection;
+using System.Xml;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.DataSnapshot.Interfaces;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.DataSnapshot.Providers
+{
+    public class ObjectSnapshot : IDataSnapshotProvider
+    {
+        private Scene m_scene = null;
+        // private DataSnapshotManager m_parent = null;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private bool m_stale = true;
+
+        private static UUID m_DefaultImage = new UUID("89556747-24cb-43ed-920b-47caed15465f");
+        private static UUID m_BlankImage = new UUID("5748decc-f629-461c-9a36-a35a221fe21f");
+
+
+        public void Initialize(Scene scene, DataSnapshotManager parent)
+        {
+            m_scene = scene;
+            // m_parent = parent;
+
+            //To check for staleness, we must catch all incoming client packets.
+            m_scene.EventManager.OnNewClient += OnNewClient;
+            m_scene.EventManager.OnParcelPrimCountAdd += delegate(SceneObjectGroup obj) { this.Stale = true; };
+        }
+
+        public void OnNewClient(IClientAPI client)
+        {
+            //Detect object data changes by hooking into the IClientAPI.
+            //Very dirty, and breaks whenever someone changes the client API.
+
+            client.OnAddPrim += delegate (UUID ownerID, UUID groupID, Vector3 RayEnd, Quaternion rot,
+                PrimitiveBaseShape shape, byte bypassRaycast, Vector3 RayStart, UUID RayTargetID,
+                byte RayEndIsIntersection) { this.Stale = true; };
+            client.OnLinkObjects += delegate (IClientAPI remoteClient, uint parent, List<uint> children)
+                { this.Stale = true; };
+            client.OnDelinkObjects += delegate(List<uint> primIds, IClientAPI clientApi) { this.Stale = true; };
+            client.OnGrabUpdate += delegate(UUID objectID, Vector3 offset, Vector3 grapPos,
+                IClientAPI remoteClient, List<SurfaceTouchEventArgs> surfaceArgs) { this.Stale = true; };
+            client.OnObjectAttach += delegate(IClientAPI remoteClient, uint objectLocalID, uint AttachmentPt,
+                bool silent) { this.Stale = true; };
+            client.OnObjectDuplicate += delegate(uint localID, Vector3 offset, uint dupeFlags, UUID AgentID,
+                UUID GroupID) { this.Stale = true; };
+            client.OnObjectDuplicateOnRay += delegate(uint localID, uint dupeFlags, UUID AgentID, UUID GroupID,
+                UUID RayTargetObj, Vector3 RayEnd, Vector3 RayStart, bool BypassRaycast,
+                bool RayEndIsIntersection, bool CopyCenters, bool CopyRotates) { this.Stale = true; };
+            client.OnObjectIncludeInSearch += delegate(IClientAPI remoteClient, bool IncludeInSearch, uint localID)
+                { this.Stale = true; };
+            client.OnObjectPermissions += delegate(IClientAPI controller, UUID agentID, UUID sessionID,
+                byte field, uint localId, uint mask, byte set) { this.Stale = true; };
+            client.OnRezObject += delegate(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd,
+                Vector3 RayStart, UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
+                bool RezSelected,
+                bool RemoveItem, UUID fromTaskID) { this.Stale = true; };
+        }
+
+        public Scene GetParentScene
+        {
+            get { return m_scene; }
+        }
+
+        public XmlNode RequestSnapshotData(XmlDocument nodeFactory)
+        {
+            m_log.Debug("[DATASNAPSHOT]: Generating object data for scene " + m_scene.RegionInfo.RegionName);
+
+            XmlNode parent = nodeFactory.CreateNode(XmlNodeType.Element, "objectdata", "");
+            XmlNode node;
+
+            EntityBase[] entities = m_scene.Entities.GetEntities();
+            foreach (EntityBase entity in entities)
+            {
+                // only objects, not avatars
+                if (entity is SceneObjectGroup)
+                {
+                    SceneObjectGroup obj = (SceneObjectGroup)entity;
+
+//                    m_log.Debug("[DATASNAPSHOT]: Found object " + obj.Name + " in scene");
+
+                    // libomv will complain about PrimFlags.JointWheel
+                    // being obsolete, so we...
+                    #pragma warning disable 0612
+                    if ((obj.RootPart.Flags & PrimFlags.JointWheel) == PrimFlags.JointWheel)
+                    {
+                        SceneObjectPart m_rootPart = obj.RootPart;
+
+                        ILandObject land = m_scene.LandChannel.GetLandObject(m_rootPart.AbsolutePosition.X, m_rootPart.AbsolutePosition.Y);
+
+                        XmlNode xmlobject = nodeFactory.CreateNode(XmlNodeType.Element, "object", "");
+                        node = nodeFactory.CreateNode(XmlNodeType.Element, "uuid", "");
+                        node.InnerText = obj.UUID.ToString();
+                        xmlobject.AppendChild(node);
+
+                        node = nodeFactory.CreateNode(XmlNodeType.Element, "title", "");
+                        node.InnerText = m_rootPart.Name;
+                        xmlobject.AppendChild(node);
+
+                        node = nodeFactory.CreateNode(XmlNodeType.Element, "description", "");
+                        node.InnerText = m_rootPart.Description;
+                        xmlobject.AppendChild(node);
+
+                        node = nodeFactory.CreateNode(XmlNodeType.Element, "flags", "");
+                        node.InnerText = String.Format("{0:x}", (uint)m_rootPart.Flags);
+                        xmlobject.AppendChild(node);
+
+                        node = nodeFactory.CreateNode(XmlNodeType.Element, "regionuuid", "");
+                        node.InnerText = m_scene.RegionInfo.RegionSettings.RegionUUID.ToString();
+                        xmlobject.AppendChild(node);
+
+                        if (land != null && land.LandData != null)
+                        {
+                            node = nodeFactory.CreateNode(XmlNodeType.Element, "parceluuid", "");
+                            node.InnerText = land.LandData.GlobalID.ToString();
+                            xmlobject.AppendChild(node);
+                        }
+                        else
+                        {
+                            // Something is wrong with this object. Let's not list it.
+                            m_log.WarnFormat("[DATASNAPSHOT]: Bad data for object {0} ({1}) in region {2}", obj.Name, obj.UUID, m_scene.RegionInfo.RegionName);
+                            continue;
+                        }
+
+                        node = nodeFactory.CreateNode(XmlNodeType.Element, "location", "");
+                        Vector3 loc = obj.AbsolutePosition;
+                        node.InnerText = loc.X.ToString() + "/" + loc.Y.ToString() + "/" + loc.Z.ToString();
+                        xmlobject.AppendChild(node);
+
+                        string bestImage = GuessImage(obj);
+                        if (bestImage != string.Empty)
+                        {
+                            node = nodeFactory.CreateNode(XmlNodeType.Element, "image", "");
+                            node.InnerText = bestImage;
+                            xmlobject.AppendChild(node);
+                        }
+
+                        parent.AppendChild(xmlobject);
+                    }
+                    #pragma warning disable 0612
+                }
+            }
+            this.Stale = false;
+            return parent;
+        }
+
+        public String Name
+        {
+            get { return "ObjectSnapshot"; }
+        }
+
+        public bool Stale
+        {
+            get
+            {
+                return m_stale;
+            }
+            set
+            {
+                m_stale = value;
+
+                if (m_stale)
+                    OnStale(this);
+            }
+        }
+
+        public event ProviderStale OnStale;
+
+        /// <summary>
+        /// Guesses the best image, based on a simple heuristic. It guesses only for boxes.
+        /// We're optimizing for boxes, because those are the most common objects
+        /// marked "Show in search" -- boxes with content inside.For other shapes,
+        /// it's really hard to tell which texture should be grabbed.
+        /// </summary>
+        /// <param name="sog"></param>
+        /// <returns></returns>
+        private string GuessImage(SceneObjectGroup sog)
+        {
+            string bestguess = string.Empty;
+            Dictionary<UUID, int> counts = new Dictionary<UUID, int>();
+
+            PrimitiveBaseShape shape = sog.RootPart.Shape;
+            if (shape != null && shape.ProfileShape == ProfileShape.Square)
+            {
+                Primitive.TextureEntry textures = shape.Textures;
+                if (textures != null)
+                {
+                    if (textures.DefaultTexture != null &&
+                        textures.DefaultTexture.TextureID != UUID.Zero &&
+                        textures.DefaultTexture.TextureID != m_DefaultImage &&
+                        textures.DefaultTexture.TextureID != m_BlankImage &&
+                        textures.DefaultTexture.RGBA.A < 50f)
+                    {
+                        counts[textures.DefaultTexture.TextureID] = 8;
+                    }
+
+                    if (textures.FaceTextures != null)
+                    {
+                        foreach (Primitive.TextureEntryFace tentry in textures.FaceTextures)
+                        {
+                            if (tentry != null)
+                            {
+                                if (tentry.TextureID != UUID.Zero && tentry.TextureID != m_DefaultImage && tentry.TextureID != m_BlankImage && tentry.RGBA.A < 50)
+                                {
+                                    int c = 0;
+                                    counts.TryGetValue(tentry.TextureID, out c);
+                                    counts[tentry.TextureID] = c + 1;
+                                    // decrease the default texture count
+                                    if (counts.ContainsKey(textures.DefaultTexture.TextureID))
+                                        counts[textures.DefaultTexture.TextureID] = counts[textures.DefaultTexture.TextureID] - 1;
+                                }
+                            }
+                        }
+                    }
+
+                    // Let's pick the most unique texture
+                    int min = 9999;
+                    foreach (KeyValuePair<UUID, int> kv in counts)
+                    {
+                        if (kv.Value < min && kv.Value >= 1)
+                        {
+                            bestguess = kv.Key.ToString();
+                            min = kv.Value;
+                        }
+                    }
+                }
+            }
+
+            return bestguess;
+        }
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/DataSnapshot/SnapshotStore.cs b/OpenSim/Region/OptionalModules/DataSnapshot/SnapshotStore.cs
new file mode 100644
index 0000000..480aaaf
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/DataSnapshot/SnapshotStore.cs
@@ -0,0 +1,337 @@
+/*
+* 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.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using log4net;
+using OpenSim.Region.DataSnapshot.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.DataSnapshot
+{
+    public class SnapshotStore
+    {
+        #region Class Members
+        private String m_directory = "unyuu"; //not an attempt at adding RM references to core SVN, honest
+        private Dictionary<Scene, bool> m_scenes = null;
+        private List<IDataSnapshotProvider> m_providers = null;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Dictionary<String, String> m_gridinfo = null;
+        private bool m_cacheEnabled = true;
+        private string m_listener_port = "9000"; //TODO: Set default port over 9000
+        private string m_hostname = "127.0.0.1";
+        #endregion
+
+        public SnapshotStore(string directory, Dictionary<String, String> gridinfo, string port, string hostname) {
+            m_directory = directory;
+            m_scenes = new Dictionary<Scene, bool>();
+            m_providers = new List<IDataSnapshotProvider>();
+            m_gridinfo = gridinfo;
+            m_listener_port = port;
+            m_hostname = hostname;
+
+            if (Directory.Exists(m_directory))
+            {
+                m_log.Info("[DATASNAPSHOT]: Response and fragment cache directory already exists.");
+            }
+            else
+            {
+                // Try to create the directory.
+                m_log.Info("[DATASNAPSHOT]: Creating directory " + m_directory);
+                try
+                {
+                    Directory.CreateDirectory(m_directory);
+                }
+                catch (Exception e)
+                {
+                    m_log.Error("[DATASNAPSHOT]: Failed to create directory " + m_directory, e);
+
+                    //This isn't a horrible problem, just disable cacheing.
+                    m_cacheEnabled = false;
+                    m_log.Error("[DATASNAPSHOT]: Could not create directory, response cache has been disabled.");
+                }
+            }
+        }
+
+        public void ForceSceneStale(Scene scene) {
+            m_scenes[scene] = true;
+        }
+
+        #region Fragment storage
+        public XmlNode GetFragment(IDataSnapshotProvider provider, XmlDocument factory)
+        {
+            XmlNode data = null;
+
+            if (provider.Stale || !m_cacheEnabled)
+            {
+                data = provider.RequestSnapshotData(factory);
+
+                if (m_cacheEnabled)
+                {
+                    String path = DataFileNameFragment(provider.GetParentScene, provider.Name);
+
+                    try
+                    {
+                        using (XmlTextWriter snapXWriter = new XmlTextWriter(path, Encoding.Default))
+                        {
+                            snapXWriter.Formatting = Formatting.Indented;
+                            snapXWriter.WriteStartDocument();
+                            data.WriteTo(snapXWriter);
+                            snapXWriter.WriteEndDocument();
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.WarnFormat("[DATASNAPSHOT]: Exception on writing to file {0}: {1}", path, e.Message);
+                    }
+
+                }
+
+                //mark provider as not stale, parent scene as stale
+                provider.Stale = false;
+                m_scenes[provider.GetParentScene] = true;
+
+                m_log.Debug("[DATASNAPSHOT]: Generated fragment response for provider type " + provider.Name);
+            }
+            else
+            {
+                String path = DataFileNameFragment(provider.GetParentScene, provider.Name);
+
+                XmlDocument fragDocument = new XmlDocument();
+                fragDocument.PreserveWhitespace = true;
+                fragDocument.Load(path);
+                foreach (XmlNode node in fragDocument)
+                {
+                    data = factory.ImportNode(node, true);
+                }
+
+                m_log.Debug("[DATASNAPSHOT]: Retrieved fragment response for provider type " + provider.Name);
+            }
+
+            return data;
+        }
+        #endregion
+
+        #region Response storage
+        public XmlNode GetScene(Scene scene, XmlDocument factory)
+        {
+            m_log.Debug("[DATASNAPSHOT]: Data requested for scene " + scene.RegionInfo.RegionName);
+
+            if (!m_scenes.ContainsKey(scene)) {
+                m_scenes.Add(scene, true); //stale by default
+            }
+
+            XmlNode regionElement = null;
+
+            if (!m_scenes[scene])
+            {
+                m_log.Debug("[DATASNAPSHOT]: Attempting to retrieve snapshot from cache.");
+                //get snapshot from cache
+                String path = DataFileNameScene(scene);
+
+                XmlDocument fragDocument = new XmlDocument();
+                fragDocument.PreserveWhitespace = true;
+
+                fragDocument.Load(path);
+
+                foreach (XmlNode node in fragDocument)
+                {
+                    regionElement = factory.ImportNode(node, true);
+                }
+
+                m_log.Debug("[DATASNAPSHOT]: Obtained snapshot from cache for " + scene.RegionInfo.RegionName);
+            }
+            else
+            {
+                m_log.Debug("[DATASNAPSHOT]: Attempting to generate snapshot.");
+                //make snapshot
+                regionElement = MakeRegionNode(scene, factory);
+
+                regionElement.AppendChild(GetGridSnapshotData(factory));
+                XmlNode regionData = factory.CreateNode(XmlNodeType.Element, "data", "");
+
+                foreach (IDataSnapshotProvider dataprovider in m_providers)
+                {
+                    if (dataprovider.GetParentScene == scene)
+                    {
+                        regionData.AppendChild(GetFragment(dataprovider, factory));
+                    }
+                }
+
+                regionElement.AppendChild(regionData);
+
+                factory.AppendChild(regionElement);
+
+                //save snapshot
+                String path = DataFileNameScene(scene);
+
+                try
+                {
+                    using (XmlTextWriter snapXWriter = new XmlTextWriter(path, Encoding.Default))
+                    {
+                        snapXWriter.Formatting = Formatting.Indented;
+                        snapXWriter.WriteStartDocument();
+                        regionElement.WriteTo(snapXWriter);
+                        snapXWriter.WriteEndDocument();
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.WarnFormat("[DATASNAPSHOT]: Exception on writing to file {0}: {1}", path, e.Message);
+                }
+
+                m_scenes[scene] = false;
+
+                m_log.Debug("[DATASNAPSHOT]: Generated new snapshot for " + scene.RegionInfo.RegionName);
+            }
+
+            return regionElement;
+        }
+
+        #endregion
+
+        #region Helpers
+        private string DataFileNameFragment(Scene scene, String fragmentName)
+        {
+            return Path.Combine(m_directory, Path.ChangeExtension(Sanitize(scene.RegionInfo.RegionName + "_" + fragmentName), "xml"));
+        }
+
+        private string DataFileNameScene(Scene scene)
+        {
+            return Path.Combine(m_directory, Path.ChangeExtension(Sanitize(scene.RegionInfo.RegionName), "xml"));
+            //return (m_snapsDir + Path.DirectorySeparatorChar + scene.RegionInfo.RegionName + ".xml");
+        }
+
+        private static string Sanitize(string name)
+        {
+            string invalidChars = Regex.Escape(new string(Path.GetInvalidFileNameChars()));
+            string invalidReStr = string.Format(@"[{0}]", invalidChars);
+            string newname = Regex.Replace(name, invalidReStr, "_");
+            return newname.Replace('.', '_');
+        }
+
+        private XmlNode MakeRegionNode(Scene scene, XmlDocument basedoc)
+        {
+            XmlNode docElement = basedoc.CreateNode(XmlNodeType.Element, "region", "");
+
+            XmlAttribute attr = basedoc.CreateAttribute("category");
+            attr.Value = GetRegionCategory(scene);
+            docElement.Attributes.Append(attr);
+
+            attr = basedoc.CreateAttribute("entities");
+            attr.Value = scene.Entities.Count.ToString();
+            docElement.Attributes.Append(attr);
+
+            //attr = basedoc.CreateAttribute("parcels");
+            //attr.Value = scene.LandManager.landList.Count.ToString();
+            //docElement.Attributes.Append(attr);
+
+
+            XmlNode infoblock = basedoc.CreateNode(XmlNodeType.Element, "info", "");
+
+            XmlNode infopiece = basedoc.CreateNode(XmlNodeType.Element, "uuid", "");
+            infopiece.InnerText = scene.RegionInfo.RegionID.ToString();
+            infoblock.AppendChild(infopiece);
+
+            infopiece = basedoc.CreateNode(XmlNodeType.Element, "url", "");
+            infopiece.InnerText = "http://" + m_hostname + ":" + m_listener_port;
+            infoblock.AppendChild(infopiece);
+
+            infopiece = basedoc.CreateNode(XmlNodeType.Element, "name", "");
+            infopiece.InnerText = scene.RegionInfo.RegionName;
+            infoblock.AppendChild(infopiece);
+
+            infopiece = basedoc.CreateNode(XmlNodeType.Element, "handle", "");
+            infopiece.InnerText = scene.RegionInfo.RegionHandle.ToString();
+            infoblock.AppendChild(infopiece);
+
+            docElement.AppendChild(infoblock);
+
+            m_log.Debug("[DATASNAPSHOT]: Generated region node");
+            return docElement;
+        }
+
+        private String GetRegionCategory(Scene scene)
+        {
+            if (scene.RegionInfo.RegionSettings.Maturity == 0)
+                return "PG";
+
+            if (scene.RegionInfo.RegionSettings.Maturity == 1)
+                return "Mature";
+
+            if (scene.RegionInfo.RegionSettings.Maturity == 2)
+                return "Adult";
+
+            return "Unknown";
+        }
+
+        private XmlNode GetGridSnapshotData(XmlDocument factory)
+        {
+            XmlNode griddata = factory.CreateNode(XmlNodeType.Element, "grid", "");
+
+            foreach (KeyValuePair<String, String> GridData in m_gridinfo)
+            {
+                //TODO: make it lowercase tag names for diva
+                XmlNode childnode = factory.CreateNode(XmlNodeType.Element, GridData.Key, "");
+                childnode.InnerText = GridData.Value;
+                griddata.AppendChild(childnode);
+            }
+
+            m_log.Debug("[DATASNAPSHOT]: Got grid snapshot data");
+
+            return griddata;
+        }
+        #endregion
+
+        #region Manage internal collections
+        public void AddScene(Scene newScene)
+        {
+            m_scenes.Add(newScene, true);
+        }
+
+        public void RemoveScene(Scene deadScene)
+        {
+            m_scenes.Remove(deadScene);
+        }
+
+        public void AddProvider(IDataSnapshotProvider newProvider)
+        {
+            m_providers.Add(newProvider);
+        }
+
+        public void RemoveProvider(IDataSnapshotProvider deadProvider)
+        {
+            m_providers.Remove(deadProvider);
+        }
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/PhysicsParameters/PhysicsParameters.cs b/OpenSim/Region/OptionalModules/PhysicsParameters/PhysicsParameters.cs
index 3083a33..1d9179c 100755
--- a/OpenSim/Region/OptionalModules/PhysicsParameters/PhysicsParameters.cs
+++ b/OpenSim/Region/OptionalModules/PhysicsParameters/PhysicsParameters.cs
@@ -36,7 +36,7 @@ using OpenSim.Framework.Console;
 using OpenSim.Region.CoreModules.Framework.InterfaceCommander;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Physics.Manager;
+using OpenSim.Region.PhysicsModules.SharedBase;
 
 namespace OpenSim.Region.OptionalModules.PhysicsParameters
 {
diff --git a/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerClientEventForwarder.cs b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerClientEventForwarder.cs
new file mode 100644
index 0000000..721d396
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerClientEventForwarder.cs
@@ -0,0 +1,94 @@
+/*
+ * 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 OpenMetaverse;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.RegionCombinerModule
+{
+public class RegionCombinerClientEventForwarder
+    {
+        private Scene m_rootScene;
+        private Dictionary<UUID, Scene> m_virtScene = new Dictionary<UUID, Scene>();
+        private Dictionary<UUID,RegionCombinerIndividualEventForwarder> m_forwarders = new Dictionary<UUID,
+            RegionCombinerIndividualEventForwarder>();
+
+        public RegionCombinerClientEventForwarder(RegionConnections rootScene)
+        {
+            m_rootScene = rootScene.RegionScene;
+        }
+
+        public void AddSceneToEventForwarding(Scene virtualScene)
+        {
+            lock (m_virtScene)
+            {
+                if (m_virtScene.ContainsKey(virtualScene.RegionInfo.originRegionID))
+                {
+                    m_virtScene[virtualScene.RegionInfo.originRegionID] = virtualScene;
+                }
+                else
+                {
+                    m_virtScene.Add(virtualScene.RegionInfo.originRegionID, virtualScene);
+                }
+            }
+            
+            lock (m_forwarders)
+            {
+                // TODO: Fix this to unregister if this happens
+                if (m_forwarders.ContainsKey(virtualScene.RegionInfo.originRegionID))
+                    m_forwarders.Remove(virtualScene.RegionInfo.originRegionID);
+
+                RegionCombinerIndividualEventForwarder forwarder =
+                    new RegionCombinerIndividualEventForwarder(m_rootScene, virtualScene);
+                m_forwarders.Add(virtualScene.RegionInfo.originRegionID, forwarder);
+
+                virtualScene.EventManager.OnNewClient += forwarder.ClientConnect;
+                virtualScene.EventManager.OnClientClosed += forwarder.ClientClosed;
+            }
+        }
+
+        public void RemoveSceneFromEventForwarding (Scene virtualScene)
+        {
+            lock (m_forwarders)
+            {
+                RegionCombinerIndividualEventForwarder forwarder = m_forwarders[virtualScene.RegionInfo.originRegionID];
+                virtualScene.EventManager.OnNewClient -= forwarder.ClientConnect;
+                virtualScene.EventManager.OnClientClosed -= forwarder.ClientClosed;
+                m_forwarders.Remove(virtualScene.RegionInfo.originRegionID);
+            }
+            lock (m_virtScene)
+            {
+                if (m_virtScene.ContainsKey(virtualScene.RegionInfo.originRegionID))
+                {
+                    m_virtScene.Remove(virtualScene.RegionInfo.originRegionID);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerIndividualEventForwarder.cs b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerIndividualEventForwarder.cs
new file mode 100644
index 0000000..83732e2
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerIndividualEventForwarder.cs
@@ -0,0 +1,139 @@
+/*
+ * 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 OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.Avatar.Attachments;
+using OpenSim.Region.CoreModules.Avatar.Gods;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.RegionCombinerModule
+{
+    public class RegionCombinerIndividualEventForwarder
+    {
+        private Scene m_rootScene;
+        private Scene m_virtScene;
+
+        public RegionCombinerIndividualEventForwarder(Scene rootScene, Scene virtScene)
+        {
+            m_rootScene = rootScene;
+            m_virtScene = virtScene;
+        }
+
+        public void ClientConnect(IClientAPI client)
+        {
+            m_virtScene.UnSubscribeToClientPrimEvents(client);
+            m_virtScene.UnSubscribeToClientPrimRezEvents(client);
+            m_virtScene.UnSubscribeToClientInventoryEvents(client);
+            if(m_virtScene.AttachmentsModule != null)
+                ((AttachmentsModule)m_virtScene.AttachmentsModule).UnsubscribeFromClientEvents(client);
+            //m_virtScene.UnSubscribeToClientTeleportEvents(client);
+            m_virtScene.UnSubscribeToClientScriptEvents(client);
+            
+            IGodsModule virtGodsModule = m_virtScene.RequestModuleInterface<IGodsModule>();
+            if (virtGodsModule != null)
+                ((GodsModule)virtGodsModule).UnsubscribeFromClientEvents(client);
+            
+            m_virtScene.UnSubscribeToClientNetworkEvents(client);
+
+            m_rootScene.SubscribeToClientPrimEvents(client);
+            client.OnAddPrim += LocalAddNewPrim;
+            client.OnRezObject += LocalRezObject;
+            
+            m_rootScene.SubscribeToClientInventoryEvents(client);
+            if (m_rootScene.AttachmentsModule != null)
+                ((AttachmentsModule)m_rootScene.AttachmentsModule).SubscribeToClientEvents(client);
+            //m_rootScene.SubscribeToClientTeleportEvents(client);
+            m_rootScene.SubscribeToClientScriptEvents(client);
+            
+            IGodsModule rootGodsModule = m_virtScene.RequestModuleInterface<IGodsModule>();
+            if (rootGodsModule != null)
+                ((GodsModule)rootGodsModule).UnsubscribeFromClientEvents(client);
+            
+            m_rootScene.SubscribeToClientNetworkEvents(client);
+        }
+
+        public void ClientClosed(UUID clientid, Scene scene)
+        {
+        }
+
+        /// <summary>
+        /// Fixes position based on the region the Rez event came in on
+        /// </summary>
+        /// <param name="remoteclient"></param>
+        /// <param name="itemid"></param>
+        /// <param name="rayend"></param>
+        /// <param name="raystart"></param>
+        /// <param name="raytargetid"></param>
+        /// <param name="bypassraycast"></param>
+        /// <param name="rayendisintersection"></param>
+        /// <param name="rezselected"></param>
+        /// <param name="removeitem"></param>
+        /// <param name="fromtaskid"></param>
+        private void LocalRezObject(IClientAPI remoteclient, UUID itemid, Vector3 rayend, Vector3 raystart, 
+            UUID raytargetid, byte bypassraycast, bool rayendisintersection, bool rezselected, bool removeitem, 
+            UUID fromtaskid)
+        {
+            int differenceX = (int)m_virtScene.RegionInfo.RegionLocX - (int)m_rootScene.RegionInfo.RegionLocX;
+            int differenceY = (int)m_virtScene.RegionInfo.RegionLocY - (int)m_rootScene.RegionInfo.RegionLocY;
+            rayend.X += differenceX * (int)Constants.RegionSize;
+            rayend.Y += differenceY * (int)Constants.RegionSize;
+            raystart.X += differenceX * (int)Constants.RegionSize;
+            raystart.Y += differenceY * (int)Constants.RegionSize;
+
+            m_rootScene.RezObject(remoteclient, itemid, rayend, raystart, raytargetid, bypassraycast,
+                                  rayendisintersection, rezselected, removeitem, fromtaskid);
+        }
+        /// <summary>
+        /// Fixes position based on the region the AddPrimShape event came in on
+        /// </summary>
+        /// <param name="ownerid"></param>
+        /// <param name="groupid"></param>
+        /// <param name="rayend"></param>
+        /// <param name="rot"></param>
+        /// <param name="shape"></param>
+        /// <param name="bypassraycast"></param>
+        /// <param name="raystart"></param>
+        /// <param name="raytargetid"></param>
+        /// <param name="rayendisintersection"></param>
+        private void LocalAddNewPrim(UUID ownerid, UUID groupid, Vector3 rayend, Quaternion rot, 
+            PrimitiveBaseShape shape, byte bypassraycast, Vector3 raystart, UUID raytargetid, 
+            byte rayendisintersection)
+        {
+            int differenceX = (int)m_virtScene.RegionInfo.RegionLocX - (int)m_rootScene.RegionInfo.RegionLocX;
+            int differenceY = (int)m_virtScene.RegionInfo.RegionLocY - (int)m_rootScene.RegionInfo.RegionLocY;
+            rayend.X += differenceX * (int)Constants.RegionSize;
+            rayend.Y += differenceY * (int)Constants.RegionSize;
+            raystart.X += differenceX * (int)Constants.RegionSize;
+            raystart.Y += differenceY * (int)Constants.RegionSize;
+            m_rootScene.AddNewPrim(ownerid, groupid, rayend, rot, shape, bypassraycast, raystart, raytargetid,
+                                   rayendisintersection);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerLargeLandChannel.cs b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerLargeLandChannel.cs
new file mode 100644
index 0000000..e5e76e9
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerLargeLandChannel.cs
@@ -0,0 +1,202 @@
+/*
+ * 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.Reflection;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.CoreModules.World.Land;
+
+namespace OpenSim.Region.RegionCombinerModule
+{
+    public class RegionCombinerLargeLandChannel : ILandChannel
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private RegionData RegData;
+        private ILandChannel RootRegionLandChannel;
+        private readonly List<RegionData> RegionConnections;
+        
+        #region ILandChannel Members
+
+        public RegionCombinerLargeLandChannel(RegionData regData, ILandChannel rootRegionLandChannel,
+                                              List<RegionData> regionConnections)
+        {
+            RegData = regData;
+            RootRegionLandChannel = rootRegionLandChannel;
+            RegionConnections = regionConnections;
+        }
+
+        public List<ILandObject> ParcelsNearPoint(Vector3 position)
+        {
+            //m_log.DebugFormat("[LANDPARCELNEARPOINT]: {0}>", position);
+            return RootRegionLandChannel.ParcelsNearPoint(position - RegData.Offset);
+        }
+
+        public List<ILandObject> AllParcels()
+        {
+            return RootRegionLandChannel.AllParcels();
+        }
+        
+        public void Clear(bool setupDefaultParcel)
+        {
+            RootRegionLandChannel.Clear(setupDefaultParcel);
+        }
+
+        public ILandObject GetLandObject(Vector3 position)
+        {
+            return GetLandObject(position.X, position.Y);
+        }
+
+        public ILandObject GetLandObject(int x, int y)
+        {
+            return GetLandObject((float)x, (float)y);
+
+//            m_log.DebugFormat("[BIGLANDTESTINT]: <{0},{1}>", x, y);
+//
+//            if (x > 0 && x <= (int)Constants.RegionSize && y > 0 && y <= (int)Constants.RegionSize)
+//            {
+//                return RootRegionLandChannel.GetLandObject(x, y);
+//            }
+//            else
+//            {
+//                int offsetX = (x / (int)Constants.RegionSize);
+//                int offsetY = (y / (int)Constants.RegionSize);
+//                offsetX *= (int)Constants.RegionSize;
+//                offsetY *= (int)Constants.RegionSize;
+//
+//                foreach (RegionData regionData in RegionConnections)
+//                {
+//                    if (regionData.Offset.X == offsetX && regionData.Offset.Y == offsetY)
+//                    {
+//                        m_log.DebugFormat(
+//                            "[REGION COMBINER LARGE LAND CHANNEL]: Found region {0} at offset {1},{2}", 
+//                            regionData.RegionScene.Name, offsetX, offsetY);
+//
+//                        return regionData.RegionScene.LandChannel.GetLandObject(x - offsetX, y - offsetY);
+//                    }
+//                }
+//                //ILandObject obj = new LandObject(UUID.Zero, false, RegData.RegionScene);
+//                //obj.LandData.Name = "NO LAND";
+//                //return obj;
+//            }
+//
+//            m_log.DebugFormat("[REGION COMBINER LARGE LAND CHANNEL]: No region found at {0},{1}, returning null", x, y);
+//
+//            return null;
+        }
+
+        public ILandObject GetLandObject(int localID)
+        {
+            // XXX: Possibly should be looking in every land channel, not just the root.
+            return RootRegionLandChannel.GetLandObject(localID);
+        }
+
+        public ILandObject GetLandObject(float x, float y)
+        {
+//            m_log.DebugFormat("[BIGLANDTESTFLOAT]: <{0},{1}>", x, y);
+            
+            if (x > 0 && x <= (int)Constants.RegionSize && y > 0 && y <= (int)Constants.RegionSize)
+            {
+                return RootRegionLandChannel.GetLandObject(x, y);
+            }
+            else
+            {
+                int offsetX = (int)(x/(int) Constants.RegionSize);
+                int offsetY = (int)(y/(int) Constants.RegionSize);
+                offsetX *= (int) Constants.RegionSize;
+                offsetY *= (int) Constants.RegionSize;
+
+                foreach (RegionData regionData in RegionConnections)
+                {
+                    if (regionData.Offset.X == offsetX && regionData.Offset.Y == offsetY)
+                    {
+//                        m_log.DebugFormat(
+//                            "[REGION COMBINER LARGE LAND CHANNEL]: Found region {0} at offset {1},{2}", 
+//                            regionData.RegionScene.Name, offsetX, offsetY);
+
+                        return regionData.RegionScene.LandChannel.GetLandObject(x - offsetX, y - offsetY);
+                    }
+                }
+
+//                ILandObject obj = new LandObject(UUID.Zero, false, RegData.RegionScene);
+//                obj.LandData.Name = "NO LAND";
+//                return obj;
+            }
+
+//            m_log.DebugFormat("[REGION COMBINER LARGE LAND CHANNEL]: No region found at {0},{1}, returning null", x, y);
+
+            return null;
+        }
+
+        public bool IsForcefulBansAllowed()
+        {
+            return RootRegionLandChannel.IsForcefulBansAllowed();
+        }
+
+        public void UpdateLandObject(int localID, LandData data)
+        {
+            RootRegionLandChannel.UpdateLandObject(localID, data);
+        }
+
+        public void Join(int start_x, int start_y, int end_x, int end_y, UUID attempting_user_id)
+        {
+            RootRegionLandChannel.Join(start_x, start_y, end_x, end_y, attempting_user_id);
+        }
+
+        public void Subdivide(int start_x, int start_y, int end_x, int end_y, UUID attempting_user_id)
+        {
+            RootRegionLandChannel.Subdivide(start_x, start_y, end_x, end_y, attempting_user_id);
+        }
+
+        public void ReturnObjectsInParcel(int localID, uint returnType, UUID[] agentIDs, UUID[] taskIDs, IClientAPI remoteClient)
+        {
+            RootRegionLandChannel.ReturnObjectsInParcel(localID, returnType, agentIDs, taskIDs, remoteClient);
+        }
+
+        public void setParcelObjectMaxOverride(overrideParcelMaxPrimCountDelegate overrideDel)
+        {
+            RootRegionLandChannel.setParcelObjectMaxOverride(overrideDel);
+        }
+
+        public void setSimulatorObjectMaxOverride(overrideSimulatorMaxPrimCountDelegate overrideDel)
+        {
+            RootRegionLandChannel.setSimulatorObjectMaxOverride(overrideDel);
+        }
+
+        public void SetParcelOtherCleanTime(IClientAPI remoteClient, int localID, int otherCleanTime)
+        {
+            RootRegionLandChannel.SetParcelOtherCleanTime(remoteClient, localID, otherCleanTime);
+        }
+
+        public void sendClientInitialLandInfo(IClientAPI remoteClient) { }
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerModule.cs b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerModule.cs
new file mode 100644
index 0000000..98b0ae1
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerModule.cs
@@ -0,0 +1,878 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Console;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using Mono.Addins;
+
+namespace OpenSim.Region.RegionCombinerModule
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "RegionCombinerModule")]
+    public class RegionCombinerModule : ISharedRegionModule, IRegionCombinerModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+//        private static string LogHeader = "[REGION COMBINER MODULE]";
+
+        public string Name
+        {
+            get { return "RegionCombinerModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        /// <summary>
+        /// Is this module enabled?
+        /// </summary>
+        private bool m_combineContiguousRegions = false;
+
+        /// <summary>
+        /// This holds the root regions for the megaregions.
+        /// </summary>
+        /// <remarks>
+        /// Usually there is only ever one megaregion (and hence only one entry here).
+        /// </remarks>
+        private Dictionary<UUID, RegionConnections> m_regions = new Dictionary<UUID, RegionConnections>();
+
+        /// <summary>
+        /// The scenes that comprise the megaregion.
+        /// </summary>
+        private Dictionary<UUID, Scene> m_startingScenes = new Dictionary<UUID, Scene>();
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig myConfig = source.Configs["Startup"];
+            m_combineContiguousRegions = myConfig.GetBoolean("CombineContiguousRegions", false);
+
+            MainConsole.Instance.Commands.AddCommand(
+                "RegionCombinerModule", false, "fix-phantoms", "fix-phantoms",
+                "Fixes phantom objects after an import to a megaregion or a change from a megaregion back to normal regions",
+                FixPhantoms);
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (m_combineContiguousRegions)
+                scene.RegisterModuleInterface<IRegionCombinerModule>(this);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            lock (m_startingScenes)
+                m_startingScenes.Remove(scene.RegionInfo.originRegionID);
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            lock (m_startingScenes)
+                m_startingScenes.Add(scene.RegionInfo.originRegionID, scene);
+
+            if (m_combineContiguousRegions)
+            {
+                RegionLoadedDoWork(scene);
+
+                scene.EventManager.OnNewPresence += NewPresence;
+            }
+        }
+
+        public bool IsRootForMegaregion(UUID regionId)
+        {
+            lock (m_regions)
+                return m_regions.ContainsKey(regionId);
+        }
+
+        public Vector2 GetSizeOfMegaregion(UUID regionId)
+        {
+            lock (m_regions)
+            {
+                if (m_regions.ContainsKey(regionId))
+                {
+                    RegionConnections rootConn = m_regions[regionId];
+
+                    return new Vector2((float)rootConn.XEnd, (float)rootConn.YEnd);
+                }
+            }
+
+            throw new Exception(string.Format("Region with id {0} not found", regionId));
+        }
+
+        // Test to see if this postiion (relative to the region) is within the area covered
+        //    by this megaregion.
+        public bool PositionIsInMegaregion(UUID currentRegion, int xx, int yy)
+        {
+            bool ret = false;
+            if (xx < 0 || yy < 0)
+                return ret;
+
+            foreach (RegionConnections rootRegion in m_regions.Values)
+            {
+                if (currentRegion == rootRegion.RegionId)
+                {
+                    // The caller is in the root region so this is an easy test
+                    if (xx < rootRegion.XEnd && yy < rootRegion.YEnd)
+                    {
+                        ret = true;
+                    }
+                    break;
+                }
+                else
+                {
+                    // Maybe the caller is in one of the sub-regions
+                    foreach (RegionData childRegion in rootRegion.ConnectedRegions)
+                    {
+                        if (currentRegion == childRegion.RegionId)
+                        {
+                            // This is a child. Diddle the offsets and check if in
+                            Vector3 positionInMegaregion = childRegion.Offset;
+                            positionInMegaregion.X += xx;
+                            positionInMegaregion.Y += yy;
+                            if (positionInMegaregion.X < rootRegion.XEnd && positionInMegaregion.Y < rootRegion.YEnd)
+                            {
+                                ret = true;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return ret;
+        }
+
+        private void NewPresence(ScenePresence presence)
+        {
+            if (presence.IsChildAgent)
+            {
+                byte[] throttleData;
+
+                try
+                {
+                    throttleData = presence.ControllingClient.GetThrottlesPacked(1);
+                } 
+                catch (NotImplementedException)
+                {
+                    return;
+                }
+
+                if (throttleData == null)
+                    return;
+
+                if (throttleData.Length == 0)
+                    return;
+
+                if (throttleData.Length != 28)
+                    return;
+
+                byte[] adjData;
+                int pos = 0;
+
+                if (!BitConverter.IsLittleEndian)
+                {
+                    byte[] newData = new byte[7 * 4];
+                    Buffer.BlockCopy(throttleData, 0, newData, 0, 7 * 4);
+
+                    for (int i = 0; i < 7; i++)
+                        Array.Reverse(newData, i * 4, 4);
+
+                    adjData = newData;
+                }
+                else
+                {
+                    adjData = throttleData;
+                }
+
+                // 0.125f converts from bits to bytes
+                int resend = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
+                int land = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
+                int wind = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
+                int cloud = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
+                int task = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
+                int texture = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
+                int asset = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f);
+                // State is a subcategory of task that we allocate a percentage to
+
+
+                //int total = resend + land + wind + cloud + task + texture + asset;
+
+                byte[] data = new byte[7 * 4];
+                int ii = 0;
+
+                Buffer.BlockCopy(Utils.FloatToBytes(resend), 0, data, ii, 4); ii += 4;
+                Buffer.BlockCopy(Utils.FloatToBytes(land * 50), 0, data, ii, 4); ii += 4;
+                Buffer.BlockCopy(Utils.FloatToBytes(wind), 0, data, ii, 4); ii += 4;
+                Buffer.BlockCopy(Utils.FloatToBytes(cloud), 0, data, ii, 4); ii += 4;
+                Buffer.BlockCopy(Utils.FloatToBytes(task), 0, data, ii, 4); ii += 4;
+                Buffer.BlockCopy(Utils.FloatToBytes(texture), 0, data, ii, 4); ii += 4;
+                Buffer.BlockCopy(Utils.FloatToBytes(asset), 0, data, ii, 4);
+
+                try
+                {
+                    presence.ControllingClient.SetChildAgentThrottle(data);
+                }
+                catch (NotImplementedException)
+                {
+                    return;
+                }
+            }
+        }
+
+        private void RegionLoadedDoWork(Scene scene)
+        {
+/* 
+            // For testing on a single instance
+            if (scene.RegionInfo.RegionLocX == 1004 && scene.RegionInfo.RegionLocY == 1000)
+                return;
+            // 
+*/
+
+            RegionConnections newConn = new RegionConnections();
+            newConn.ConnectedRegions = new List<RegionData>();
+            newConn.RegionScene = scene;
+            newConn.RegionLandChannel = scene.LandChannel;
+            newConn.RegionId = scene.RegionInfo.originRegionID;
+            newConn.X = scene.RegionInfo.RegionLocX;
+            newConn.Y = scene.RegionInfo.RegionLocY;
+            newConn.XEnd = scene.RegionInfo.RegionSizeX;
+            newConn.YEnd = scene.RegionInfo.RegionSizeX;
+
+            lock (m_regions)
+            {
+                bool connectedYN = false;
+
+                foreach (RegionConnections rootConn in m_regions.Values)
+                {
+                    #region commented
+                    /*
+                    // If we're one region over +x +y
+                    //xxy
+                    //xxx
+                    //xxx
+                    if ((((int)conn.X * (int)Constants.RegionSize) + conn.XEnd 
+                        == (regionConnections.X * (int)Constants.RegionSize)) 
+                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd 
+                        == (regionConnections.Y * (int)Constants.RegionSize)))
+                    {
+                        Vector3 offset = Vector3.Zero;
+                        offset.X = (((regionConnections.X * (int) Constants.RegionSize)) -
+                                    ((conn.X * (int) Constants.RegionSize)));
+                        offset.Y = (((regionConnections.Y * (int) Constants.RegionSize)) -
+                                    ((conn.Y * (int) Constants.RegionSize)));
+
+                        Vector3 extents = Vector3.Zero;
+                        extents.Y = regionConnections.YEnd + conn.YEnd;
+                        extents.X = conn.XEnd + conn.XEnd;
+
+                        m_log.DebugFormat("Scene: {0} to the northwest of Scene{1}.  Offset: {2}.  Extents:{3}",
+                                          conn.RegionScene.RegionInfo.RegionName,
+                                          regionConnections.RegionScene.RegionInfo.RegionName,
+                                          offset, extents);
+
+                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
+                            
+                        connectedYN = true;
+                        break;
+                    }
+                    */
+
+                    /*
+                    //If we're one region over x +y
+                    //xxx
+                    //xxx
+                    //xyx
+                    if ((((int)conn.X * (int)Constants.RegionSize)
+                        == (regionConnections.X * (int)Constants.RegionSize))
+                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
+                        == (regionConnections.Y * (int)Constants.RegionSize)))
+                    {
+                        Vector3 offset = Vector3.Zero;
+                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
+                                    ((conn.X * (int)Constants.RegionSize)));
+                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
+                                    ((conn.Y * (int)Constants.RegionSize)));
+
+                        Vector3 extents = Vector3.Zero;
+                        extents.Y = regionConnections.YEnd + conn.YEnd;
+                        extents.X = conn.XEnd;
+
+                        m_log.DebugFormat("Scene: {0} to the north of Scene{1}.  Offset: {2}. Extents:{3}",
+                                          conn.RegionScene.RegionInfo.RegionName,
+                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);
+
+                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
+                        connectedYN = true;
+                        break;
+                    }
+                    */
+
+                    /*
+                    // If we're one region over -x +y
+                    //xxx
+                    //xxx
+                    //yxx
+                    if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
+                        == (regionConnections.X * (int)Constants.RegionSize))
+                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
+                        == (regionConnections.Y * (int)Constants.RegionSize)))
+                    {
+                        Vector3 offset = Vector3.Zero;
+                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
+                                    ((conn.X * (int)Constants.RegionSize)));
+                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
+                                    ((conn.Y * (int)Constants.RegionSize)));
+
+                        Vector3 extents = Vector3.Zero;
+                        extents.Y = regionConnections.YEnd + conn.YEnd;
+                        extents.X = conn.XEnd + conn.XEnd;
+
+                        m_log.DebugFormat("Scene: {0} to the northeast of Scene.  Offset: {2}. Extents:{3}",
+                                          conn.RegionScene.RegionInfo.RegionName,
+                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);
+
+                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
+
+
+                        connectedYN = true;
+                        break;
+                    }
+                    */
+
+                    /*
+                    // If we're one region over -x y
+                    //xxx
+                    //yxx
+                    //xxx
+                    if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
+                        == (regionConnections.X * (int)Constants.RegionSize))
+                        && (((int)conn.Y * (int)Constants.RegionSize)
+                        == (regionConnections.Y * (int)Constants.RegionSize)))
+                    {
+                        Vector3 offset = Vector3.Zero;
+                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
+                                    ((conn.X * (int)Constants.RegionSize)));
+                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
+                                    ((conn.Y * (int)Constants.RegionSize)));
+
+                        Vector3 extents = Vector3.Zero;
+                        extents.Y = regionConnections.YEnd;
+                        extents.X = conn.XEnd + conn.XEnd;
+
+                        m_log.DebugFormat("Scene: {0} to the east of Scene{1} Offset: {2}. Extents:{3}",
+                                          conn.RegionScene.RegionInfo.RegionName,
+                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);
+
+                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
+
+                        connectedYN = true;
+                        break;
+                    }
+                    */
+
+                    /*
+                        // If we're one region over -x -y
+                        //yxx
+                        //xxx
+                        //xxx
+                        if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
+                            == (regionConnections.X * (int)Constants.RegionSize))
+                            && (((int)conn.Y * (int)Constants.RegionSize) + conn.YEnd
+                            == (regionConnections.Y * (int)Constants.RegionSize)))
+                        {
+                            Vector3 offset = Vector3.Zero;
+                            offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
+                                        ((conn.X * (int)Constants.RegionSize)));
+                            offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
+                                        ((conn.Y * (int)Constants.RegionSize)));
+
+                            Vector3 extents = Vector3.Zero;
+                            extents.Y = regionConnections.YEnd + conn.YEnd;
+                            extents.X = conn.XEnd + conn.XEnd;
+
+                            m_log.DebugFormat("Scene: {0} to the northeast of Scene{1} Offset: {2}. Extents:{3}",
+                                              conn.RegionScene.RegionInfo.RegionName,
+                                              regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);
+
+                            scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
+
+                            connectedYN = true;
+                            break;
+                        }
+                        */
+                    #endregion
+
+
+                    // Check to see if this new region is adjacent to the root region.
+                    // Note that we expect the regions to be combined from the root region outward
+                    //    thus the requirement for the ordering in the configuration files.
+
+                    // If we're one region over +x y (i.e. root region is to the west)
+                    //xxx
+                    //xxy
+                    //xxx
+                    if (rootConn.PosX + rootConn.XEnd >= newConn.PosX && rootConn.PosY >= newConn.PosY)
+                    {
+                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
+                        break;
+                    }
+
+                    // If we're one region over x +y (i.e. root region is to the south)
+                    //xyx
+                    //xxx
+                    //xxx
+                    if (rootConn.PosX >= newConn.PosX && rootConn.PosY + rootConn.YEnd >= newConn.PosY)
+                    {
+                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
+                        break;
+                    }
+
+                    // If we're one region over +x +y (i.e. root region is to the south-west)
+                    //xxy
+                    //xxx
+                    //xxx
+                    if (rootConn.PosX + rootConn.XEnd >= newConn.PosX && rootConn.PosY + rootConn.YEnd >= newConn.PosY)
+                    {
+                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
+                        break;
+                    }
+                }
+
+                // If !connectYN means that this region is a root region
+                if (!connectedYN)
+                {
+                    DoWorkForRootRegion(newConn, scene);
+                }
+            }
+        }
+
+        private bool DoWorkForOneRegionOverPlusXY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
+        {
+            // Offset (in meters) from the base of this region to the base of the root region.
+            Vector3 offset = Vector3.Zero;
+            offset.X = newConn.PosX - rootConn.PosX;
+            offset.Y = newConn.PosY - rootConn.PosY;
+
+            // The new total size of the region (in meters)
+            // We just extend the X and Y dimensions so the extent might temporarily include areas without regions.
+            Vector3 extents = Vector3.Zero;
+            extents.X = Math.Max(rootConn.XEnd, offset.X + newConn.RegionScene.RegionInfo.RegionSizeX);
+            extents.Y = Math.Max(rootConn.YEnd, offset.Y + newConn.RegionScene.RegionInfo.RegionSizeY);
+
+            rootConn.UpdateExtents(extents);
+
+            m_log.DebugFormat(
+                "[REGION COMBINER MODULE]: Root region {0} is to the west of region {1}, Offset: {2}, Extents: {3}",
+                rootConn.RegionScene.RegionInfo.RegionName,
+                newConn.RegionScene.RegionInfo.RegionName, offset, extents);
+
+            RegionData ConnectedRegion = new RegionData();
+            ConnectedRegion.Offset = offset;
+            ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
+            ConnectedRegion.RegionScene = scene;
+            rootConn.ConnectedRegions.Add(ConnectedRegion);
+
+            // Inform root region Physics about the extents of this region
+            rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
+
+            // Inform Child region that it needs to forward it's terrain to the root region
+            scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);
+
+            // Reset Terrain..  since terrain loads before we get here, we need to load 
+            // it again so it loads in the root region
+            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
+
+            // Create a client event forwarder and add this region's events to the root region.
+            if (rootConn.ClientEventForwarder != null)
+                rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);
+
+            return true;
+        }
+
+        /*
+         * 20140215 radams1: The border stuff was removed and the addition of regions to the mega-regions
+         *   was generalized. These functions are not needed for the generalized solution but left for reference.
+        private bool DoWorkForOneRegionOverXPlusY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
+        {
+            Vector3 offset = Vector3.Zero;
+            offset.X = newConn.PosX - rootConn.PosX;
+            offset.Y = newConn.PosY - rootConn.PosY;
+
+            Vector3 extents = Vector3.Zero;
+            extents.Y = newConn.YEnd + rootConn.YEnd;
+            extents.X = rootConn.XEnd;
+            rootConn.UpdateExtents(extents);
+
+            RegionData ConnectedRegion = new RegionData();
+            ConnectedRegion.Offset = offset;
+            ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
+            ConnectedRegion.RegionScene = scene;
+            rootConn.ConnectedRegions.Add(ConnectedRegion);
+
+            m_log.DebugFormat(
+                "[REGION COMBINER MODULE]: Root region {0} is to the south of region {1}, Offset: {2}, Extents: {3}",
+                rootConn.RegionScene.RegionInfo.RegionName,
+                newConn.RegionScene.RegionInfo.RegionName, offset, extents);
+
+            rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
+            scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);
+
+            // Reset Terrain..  since terrain normally loads first.
+            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
+            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
+            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
+
+            if (rootConn.ClientEventForwarder != null)
+                rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);
+
+            return true;
+        }
+
+        private bool DoWorkForOneRegionOverPlusXPlusY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
+        {
+            Vector3 offset = Vector3.Zero;
+            offset.X = newConn.PosX - rootConn.PosX;
+            offset.Y = newConn.PosY - rootConn.PosY;
+
+            Vector3 extents = Vector3.Zero;
+
+            // We do not want to inflate the extents for regions strictly to the NE of the root region, since this
+            // would double count regions strictly to the north and east that have already been added.
+//            extents.Y = regionConnections.YEnd + conn.YEnd;
+//            extents.X = regionConnections.XEnd + conn.XEnd;
+//            conn.UpdateExtents(extents);
+
+            extents.Y = rootConn.YEnd;
+            extents.X = rootConn.XEnd;
+
+            RegionData ConnectedRegion = new RegionData();
+            ConnectedRegion.Offset = offset;
+            ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
+            ConnectedRegion.RegionScene = scene;
+
+            rootConn.ConnectedRegions.Add(ConnectedRegion);
+
+            m_log.DebugFormat(
+                "[REGION COMBINER MODULE]: Region {0} is to the southwest of Scene {1}, Offset: {2}, Extents: {3}",
+                rootConn.RegionScene.RegionInfo.RegionName,
+                newConn.RegionScene.RegionInfo.RegionName, offset, extents);
+
+            rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
+            scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);
+
+            // Reset Terrain..  since terrain normally loads first.
+            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
+            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
+            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
+
+            if (rootConn.ClientEventForwarder != null)
+                rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);
+
+            return true;
+
+            //scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset,extents);
+        }
+         */
+
+        private void DoWorkForRootRegion(RegionConnections rootConn, Scene scene)
+        {
+            m_log.DebugFormat("[REGION COMBINER MODULE]: Adding root region {0}", scene.RegionInfo.RegionName);
+
+            RegionData rdata = new RegionData();
+            rdata.Offset = Vector3.Zero;
+            rdata.RegionId = scene.RegionInfo.originRegionID;
+            rdata.RegionScene = scene;
+            // save it's land channel
+            rootConn.RegionLandChannel = scene.LandChannel;
+
+            // Substitue our landchannel
+            RegionCombinerLargeLandChannel lnd = new RegionCombinerLargeLandChannel(rdata, scene.LandChannel,
+                                                            rootConn.ConnectedRegions);
+
+            scene.LandChannel = lnd;
+
+            // Forward the permissions modules of each of the connected regions to the root region
+            lock (m_regions)
+            {
+                foreach (RegionData r in rootConn.ConnectedRegions)
+                {
+                    ForwardPermissionRequests(rootConn, r.RegionScene);
+                }
+
+                // Create the root region's Client Event Forwarder
+                rootConn.ClientEventForwarder = new RegionCombinerClientEventForwarder(rootConn);
+    
+                // Sets up the CoarseLocationUpdate forwarder for this root region
+                scene.EventManager.OnNewPresence += SetCoarseLocationDelegate;
+    
+                // Adds this root region to a dictionary of regions that are connectable
+                m_regions.Add(scene.RegionInfo.originRegionID, rootConn);
+            }
+        }
+
+        private void SetCoarseLocationDelegate(ScenePresence presence)
+        {
+            presence.SetSendCoarseLocationMethod(SendCoarseLocationUpdates);
+        }
+
+        // This delegate was refactored for non-combined regions.
+        // This combined region version will not use the pre-compiled lists of locations and ids
+        private void SendCoarseLocationUpdates(UUID sceneId, ScenePresence presence, List<Vector3> coarseLocations, List<UUID> avatarUUIDs)
+        {
+            RegionConnections connectiondata = null; 
+            lock (m_regions)
+            {
+                if (m_regions.ContainsKey(sceneId))
+                    connectiondata = m_regions[sceneId];
+                else
+                    return;
+            }
+
+            List<Vector3> CoarseLocations = new List<Vector3>();
+            List<UUID> AvatarUUIDs = new List<UUID>();
+
+            connectiondata.RegionScene.ForEachRootScenePresence(delegate(ScenePresence sp)
+            {
+                if (sp.UUID != presence.UUID)
+                {
+                    CoarseLocations.Add(sp.AbsolutePosition);
+                    AvatarUUIDs.Add(sp.UUID);
+                }
+            });
+
+            DistributeCoarseLocationUpdates(CoarseLocations, AvatarUUIDs, connectiondata, presence);
+        }
+
+        private void DistributeCoarseLocationUpdates(List<Vector3> locations, List<UUID> uuids, 
+                                                     RegionConnections connectiondata, ScenePresence rootPresence)
+        {
+            RegionData[] rdata = connectiondata.ConnectedRegions.ToArray();
+            //List<IClientAPI> clients = new List<IClientAPI>();
+            Dictionary<Vector2, RegionCoarseLocationStruct> updates = new Dictionary<Vector2, RegionCoarseLocationStruct>();
+            
+            // Root Region entry
+            RegionCoarseLocationStruct rootupdatedata = new RegionCoarseLocationStruct();
+            rootupdatedata.Locations = new List<Vector3>();
+            rootupdatedata.Uuids = new List<UUID>();
+            rootupdatedata.Offset = Vector2.Zero;
+
+            rootupdatedata.UserAPI = rootPresence.ControllingClient;
+
+            if (rootupdatedata.UserAPI != null)
+                updates.Add(Vector2.Zero, rootupdatedata);
+
+            //Each Region needs an entry or we will end up with dead minimap dots
+            foreach (RegionData regiondata in rdata)
+            {
+                Vector2 offset = new Vector2(regiondata.Offset.X, regiondata.Offset.Y);
+                RegionCoarseLocationStruct updatedata = new RegionCoarseLocationStruct();
+                updatedata.Locations = new List<Vector3>();
+                updatedata.Uuids = new List<UUID>();
+                updatedata.Offset = offset;
+
+                if (offset == Vector2.Zero)
+                    updatedata.UserAPI = rootPresence.ControllingClient;
+                else
+                    updatedata.UserAPI = LocateUsersChildAgentIClientAPI(offset, rootPresence.UUID, rdata);
+
+                if (updatedata.UserAPI != null)
+                    updates.Add(offset, updatedata);
+            }
+
+            // go over the locations and assign them to an IClientAPI
+            for (int i = 0; i < locations.Count; i++)
+            //{locations[i]/(int) Constants.RegionSize;
+            {
+                Vector3 pPosition = new Vector3((int)locations[i].X / (int)Constants.RegionSize, 
+                                                (int)locations[i].Y / (int)Constants.RegionSize, locations[i].Z);
+                Vector2 offset = new Vector2(pPosition.X*(int) Constants.RegionSize,
+                                             pPosition.Y*(int) Constants.RegionSize);
+                
+                if (!updates.ContainsKey(offset))
+                {
+                    // This shouldn't happen
+                    RegionCoarseLocationStruct updatedata = new RegionCoarseLocationStruct();
+                    updatedata.Locations = new List<Vector3>();
+                    updatedata.Uuids = new List<UUID>();
+                    updatedata.Offset = offset;
+                    
+                    if (offset == Vector2.Zero)
+                        updatedata.UserAPI = rootPresence.ControllingClient;
+                    else 
+                        updatedata.UserAPI = LocateUsersChildAgentIClientAPI(offset, rootPresence.UUID, rdata);
+
+                    updates.Add(offset,updatedata);
+                }
+                
+                updates[offset].Locations.Add(locations[i]);
+                updates[offset].Uuids.Add(uuids[i]);
+            }
+
+            // Send out the CoarseLocationupdates from their respective client connection based on where the avatar is
+            foreach (Vector2 offset in updates.Keys)
+            {
+                if (updates[offset].UserAPI != null)
+                {
+                    updates[offset].UserAPI.SendCoarseLocationUpdate(updates[offset].Uuids,updates[offset].Locations);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Locates a the Client of a particular region in an Array of RegionData based on offset
+        /// </summary>
+        /// <param name="offset"></param>
+        /// <param name="uUID"></param>
+        /// <param name="rdata"></param>
+        /// <returns>IClientAPI or null</returns>
+        private IClientAPI LocateUsersChildAgentIClientAPI(Vector2 offset, UUID uUID, RegionData[] rdata)
+        {
+            IClientAPI returnclient = null;
+            foreach (RegionData r in rdata)
+            {
+                if (r.Offset.X == offset.X && r.Offset.Y == offset.Y)
+                {
+                    return r.RegionScene.SceneGraph.GetControllingClient(uUID);
+                }
+            }
+
+            return returnclient;
+        }
+
+        public void PostInitialise()
+        {
+        }
+        
+//        /// <summary>
+//        /// TODO:
+//        /// </summary>
+//        /// <param name="rdata"></param>
+//        public void UnCombineRegion(RegionData rdata)
+//        {
+//            lock (m_regions)
+//            {
+//                if (m_regions.ContainsKey(rdata.RegionId))
+//                {
+//                    // uncombine root region and virtual regions
+//                }
+//                else
+//                {
+//                    foreach (RegionConnections r in m_regions.Values)
+//                    {
+//                        foreach (RegionData rd in r.ConnectedRegions)
+//                        {
+//                            if (rd.RegionId == rdata.RegionId)
+//                            {
+//                                // uncombine virtual region
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+
+        public void ForwardPermissionRequests(RegionConnections BigRegion, Scene VirtualRegion)
+        {
+            if (BigRegion.PermissionModule == null)
+                BigRegion.PermissionModule = new RegionCombinerPermissionModule(BigRegion.RegionScene);
+
+            VirtualRegion.Permissions.OnBypassPermissions += BigRegion.PermissionModule.BypassPermissions;
+            VirtualRegion.Permissions.OnSetBypassPermissions += BigRegion.PermissionModule.SetBypassPermissions;
+            VirtualRegion.Permissions.OnPropagatePermissions += BigRegion.PermissionModule.PropagatePermissions;
+            VirtualRegion.Permissions.OnGenerateClientFlags += BigRegion.PermissionModule.GenerateClientFlags;
+            VirtualRegion.Permissions.OnAbandonParcel += BigRegion.PermissionModule.CanAbandonParcel;
+            VirtualRegion.Permissions.OnReclaimParcel += BigRegion.PermissionModule.CanReclaimParcel;
+            VirtualRegion.Permissions.OnDeedParcel += BigRegion.PermissionModule.CanDeedParcel;
+            VirtualRegion.Permissions.OnDeedObject += BigRegion.PermissionModule.CanDeedObject;
+            VirtualRegion.Permissions.OnIsGod += BigRegion.PermissionModule.IsGod;
+            VirtualRegion.Permissions.OnDuplicateObject += BigRegion.PermissionModule.CanDuplicateObject;
+            VirtualRegion.Permissions.OnDeleteObject += BigRegion.PermissionModule.CanDeleteObject; //MAYBE FULLY IMPLEMENTED
+            VirtualRegion.Permissions.OnEditObject += BigRegion.PermissionModule.CanEditObject; //MAYBE FULLY IMPLEMENTED
+            VirtualRegion.Permissions.OnEditParcelProperties += BigRegion.PermissionModule.CanEditParcelProperties; //MAYBE FULLY IMPLEMENTED
+            VirtualRegion.Permissions.OnInstantMessage += BigRegion.PermissionModule.CanInstantMessage;
+            VirtualRegion.Permissions.OnInventoryTransfer += BigRegion.PermissionModule.CanInventoryTransfer; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnIssueEstateCommand += BigRegion.PermissionModule.CanIssueEstateCommand; //FULLY IMPLEMENTED
+            VirtualRegion.Permissions.OnMoveObject += BigRegion.PermissionModule.CanMoveObject; //MAYBE FULLY IMPLEMENTED
+            VirtualRegion.Permissions.OnObjectEntry += BigRegion.PermissionModule.CanObjectEntry;
+            VirtualRegion.Permissions.OnReturnObjects += BigRegion.PermissionModule.CanReturnObjects; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnRezObject += BigRegion.PermissionModule.CanRezObject; //MAYBE FULLY IMPLEMENTED
+            VirtualRegion.Permissions.OnRunConsoleCommand += BigRegion.PermissionModule.CanRunConsoleCommand;
+            VirtualRegion.Permissions.OnRunScript += BigRegion.PermissionModule.CanRunScript; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnCompileScript += BigRegion.PermissionModule.CanCompileScript;
+            VirtualRegion.Permissions.OnSellParcel += BigRegion.PermissionModule.CanSellParcel;
+            VirtualRegion.Permissions.OnTakeObject += BigRegion.PermissionModule.CanTakeObject;
+            VirtualRegion.Permissions.OnTakeCopyObject += BigRegion.PermissionModule.CanTakeCopyObject;
+            VirtualRegion.Permissions.OnTerraformLand += BigRegion.PermissionModule.CanTerraformLand;
+            VirtualRegion.Permissions.OnLinkObject += BigRegion.PermissionModule.CanLinkObject; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnDelinkObject += BigRegion.PermissionModule.CanDelinkObject; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnBuyLand += BigRegion.PermissionModule.CanBuyLand; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnViewNotecard += BigRegion.PermissionModule.CanViewNotecard; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnViewScript += BigRegion.PermissionModule.CanViewScript; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnEditNotecard += BigRegion.PermissionModule.CanEditNotecard; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnEditScript += BigRegion.PermissionModule.CanEditScript; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnCreateObjectInventory += BigRegion.PermissionModule.CanCreateObjectInventory; //NOT IMPLEMENTED HERE 
+            VirtualRegion.Permissions.OnEditObjectInventory += BigRegion.PermissionModule.CanEditObjectInventory;//MAYBE FULLY IMPLEMENTED
+            VirtualRegion.Permissions.OnCopyObjectInventory += BigRegion.PermissionModule.CanCopyObjectInventory; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnDeleteObjectInventory += BigRegion.PermissionModule.CanDeleteObjectInventory; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnResetScript += BigRegion.PermissionModule.CanResetScript;
+            VirtualRegion.Permissions.OnCreateUserInventory += BigRegion.PermissionModule.CanCreateUserInventory; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnCopyUserInventory += BigRegion.PermissionModule.CanCopyUserInventory; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnEditUserInventory += BigRegion.PermissionModule.CanEditUserInventory; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnDeleteUserInventory += BigRegion.PermissionModule.CanDeleteUserInventory; //NOT YET IMPLEMENTED
+            VirtualRegion.Permissions.OnTeleport += BigRegion.PermissionModule.CanTeleport; //NOT YET IMPLEMENTED
+        }
+
+        #region console commands
+
+        public void FixPhantoms(string module, string[] cmdparams)
+        {
+            List<Scene> scenes = new List<Scene>(m_startingScenes.Values);
+
+            foreach (Scene s in scenes)
+            {
+                MainConsole.Instance.OutputFormat("Fixing phantoms for {0}", s.RegionInfo.RegionName);
+                
+                s.ForEachSOG(so => so.AbsolutePosition = so.AbsolutePosition);
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerPermissionModule.cs b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerPermissionModule.cs
new file mode 100644
index 0000000..ddfe3e0
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCombinerPermissionModule.cs
@@ -0,0 +1,270 @@
+/*
+ * 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 OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.RegionCombinerModule
+{
+    public class RegionCombinerPermissionModule
+    {
+        private Scene m_rootScene;
+
+        public RegionCombinerPermissionModule(Scene RootScene)
+        {
+            m_rootScene = RootScene;
+        }
+
+        #region Permission Override
+
+        public bool BypassPermissions()
+        {
+            return m_rootScene.Permissions.BypassPermissions();
+        }
+
+        public void SetBypassPermissions(bool value)
+        {
+            m_rootScene.Permissions.SetBypassPermissions(value);
+        }
+
+        public bool PropagatePermissions()
+        {
+            return m_rootScene.Permissions.PropagatePermissions();
+        }
+
+        public uint GenerateClientFlags(UUID userid, UUID objectidid)
+        {
+            return m_rootScene.Permissions.GenerateClientFlags(userid,objectidid);
+        }
+
+        public bool CanAbandonParcel(UUID user, ILandObject parcel, Scene scene)
+        {
+            return m_rootScene.Permissions.CanAbandonParcel(user,parcel);
+        }
+
+        public bool CanReclaimParcel(UUID user, ILandObject parcel, Scene scene)
+        {
+            return m_rootScene.Permissions.CanReclaimParcel(user, parcel);
+        }
+
+        public bool CanDeedParcel(UUID user, ILandObject parcel, Scene scene)
+        {
+            return m_rootScene.Permissions.CanDeedParcel(user, parcel);
+        }
+
+        public bool CanDeedObject(UUID user, UUID @group, Scene scene)
+        {
+            return m_rootScene.Permissions.CanDeedObject(user,@group);
+        }
+
+        public bool IsGod(UUID user, Scene requestfromscene)
+        {
+            return m_rootScene.Permissions.IsGod(user);
+        }
+
+        public bool CanDuplicateObject(int objectcount, UUID objectid, UUID owner, Scene scene, Vector3 objectposition)
+        {
+            return m_rootScene.Permissions.CanDuplicateObject(objectcount, objectid, owner, objectposition);
+        }
+
+        public bool CanDeleteObject(UUID objectid, UUID deleter, Scene scene)
+        {
+            return m_rootScene.Permissions.CanDeleteObject(objectid, deleter);
+        }
+
+        public bool CanEditObject(UUID objectid, UUID editorid, Scene scene)
+        {
+            return m_rootScene.Permissions.CanEditObject(objectid, editorid);
+        }
+
+        public bool CanEditParcelProperties(UUID user, ILandObject parcel, GroupPowers g, Scene scene, bool allowManager)
+        {
+            return m_rootScene.Permissions.CanEditParcelProperties(user, parcel, g, allowManager);
+        }
+
+        public bool CanInstantMessage(UUID user, UUID target, Scene startscene)
+        {
+            return m_rootScene.Permissions.CanInstantMessage(user, target);
+        }
+
+        public bool CanInventoryTransfer(UUID user, UUID target, Scene startscene)
+        {
+            return m_rootScene.Permissions.CanInventoryTransfer(user, target);
+        }
+
+        public bool CanIssueEstateCommand(UUID user, Scene requestfromscene, bool ownercommand)
+        {
+            return m_rootScene.Permissions.CanIssueEstateCommand(user, ownercommand);
+        }
+
+        public bool CanMoveObject(UUID objectid, UUID moverid, Scene scene)
+        {
+            return m_rootScene.Permissions.CanMoveObject(objectid, moverid);
+        }
+
+        public bool CanObjectEntry(UUID objectid, bool enteringregion, Vector3 newpoint, Scene scene)
+        {
+            return m_rootScene.Permissions.CanObjectEntry(objectid, enteringregion, newpoint);
+        }
+
+        public bool CanReturnObjects(ILandObject land, UUID user, List<SceneObjectGroup> objects, Scene scene)
+        {
+            return m_rootScene.Permissions.CanReturnObjects(land, user, objects);
+        }
+
+        public bool CanRezObject(int objectcount, UUID owner, Vector3 objectposition, Scene scene)
+        {
+            return m_rootScene.Permissions.CanRezObject(objectcount, owner, objectposition);
+        }
+
+        public bool CanRunConsoleCommand(UUID user, Scene requestfromscene)
+        {
+            return m_rootScene.Permissions.CanRunConsoleCommand(user);
+        }
+
+        public bool CanRunScript(UUID script, UUID objectid, UUID user, Scene scene)
+        {
+            return m_rootScene.Permissions.CanRunScript(script, objectid, user);
+        }
+
+        public bool CanCompileScript(UUID owneruuid, int scripttype, Scene scene)
+        {
+            return m_rootScene.Permissions.CanCompileScript(owneruuid, scripttype);
+        }
+
+        public bool CanSellParcel(UUID user, ILandObject parcel, Scene scene)
+        {
+            return m_rootScene.Permissions.CanSellParcel(user, parcel);
+        }
+
+        public bool CanTakeObject(UUID objectid, UUID stealer, Scene scene)
+        {
+            return m_rootScene.Permissions.CanTakeObject(objectid, stealer);
+        }
+
+        public bool CanTakeCopyObject(UUID objectid, UUID userid, Scene inscene)
+        {
+            return m_rootScene.Permissions.CanTakeObject(objectid, userid);
+        }
+
+        public bool CanTerraformLand(UUID user, Vector3 position, Scene requestfromscene)
+        {
+            return m_rootScene.Permissions.CanTerraformLand(user, position);
+        }
+
+        public bool CanLinkObject(UUID user, UUID objectid)
+        {
+            return m_rootScene.Permissions.CanLinkObject(user, objectid);
+        }
+
+        public bool CanDelinkObject(UUID user, UUID objectid)
+        {
+            return m_rootScene.Permissions.CanDelinkObject(user, objectid);
+        }
+
+        public bool CanBuyLand(UUID user, ILandObject parcel, Scene scene)
+        {
+            return m_rootScene.Permissions.CanBuyLand(user, parcel);
+        }
+
+        public bool CanViewNotecard(UUID script, UUID objectid, UUID user, Scene scene)
+        {
+            return m_rootScene.Permissions.CanViewNotecard(script, objectid, user);
+        }
+
+        public bool CanViewScript(UUID script, UUID objectid, UUID user, Scene scene)
+        {
+            return m_rootScene.Permissions.CanViewScript(script, objectid, user);
+        }
+
+        public bool CanEditNotecard(UUID notecard, UUID objectid, UUID user, Scene scene)
+        {
+            return m_rootScene.Permissions.CanEditNotecard(notecard, objectid, user);
+        }
+
+        public bool CanEditScript(UUID script, UUID objectid, UUID user, Scene scene)
+        {
+            return m_rootScene.Permissions.CanEditScript(script, objectid, user);
+        }
+
+        public bool CanCreateObjectInventory(int invtype, UUID objectid, UUID userid)
+        {
+            return m_rootScene.Permissions.CanCreateObjectInventory(invtype, objectid, userid);
+        }
+
+        public bool CanEditObjectInventory(UUID objectid, UUID editorid, Scene scene)
+        {
+            return m_rootScene.Permissions.CanEditObjectInventory(objectid, editorid);
+        }
+
+        public bool CanCopyObjectInventory(UUID itemid, UUID objectid, UUID userid)
+        {
+            return m_rootScene.Permissions.CanCopyObjectInventory(itemid, objectid, userid);
+        }
+
+        public bool CanDeleteObjectInventory(UUID itemid, UUID objectid, UUID userid)
+        {
+            return m_rootScene.Permissions.CanDeleteObjectInventory(itemid, objectid, userid);
+        }
+
+        public bool CanResetScript(UUID prim, UUID script, UUID user, Scene scene)
+        {
+            return m_rootScene.Permissions.CanResetScript(prim, script, user);
+        }
+
+        public bool CanCreateUserInventory(int invtype, UUID userid)
+        {
+            return m_rootScene.Permissions.CanCreateUserInventory(invtype, userid);
+        }
+
+        public bool CanCopyUserInventory(UUID itemid, UUID userid)
+        {
+            return m_rootScene.Permissions.CanCopyUserInventory(itemid, userid);
+        }
+
+        public bool CanEditUserInventory(UUID itemid, UUID userid)
+        {
+            return m_rootScene.Permissions.CanEditUserInventory(itemid, userid);
+        }
+
+        public bool CanDeleteUserInventory(UUID itemid, UUID userid)
+        {
+            return m_rootScene.Permissions.CanDeleteUserInventory(itemid, userid);
+        }
+
+        public bool CanTeleport(UUID userid, Scene scene)
+        {
+            return m_rootScene.Permissions.CanTeleport(userid);
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionConnections.cs b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionConnections.cs
new file mode 100644
index 0000000..6bf1c4a
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionConnections.cs
@@ -0,0 +1,94 @@
+/*
+ * 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 OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.RegionCombinerModule
+{
+    public class RegionConnections
+    {
+        /// <summary>
+        /// Root Region ID
+        /// </summary>
+        public UUID RegionId;
+
+        /// <summary>
+        /// Root Region Scene
+        /// </summary>
+        public Scene RegionScene;
+
+        /// <summary>
+        /// LargeLandChannel for combined region
+        /// </summary>
+        public ILandChannel RegionLandChannel;
+
+        /// <summary>
+        /// The x map co-ordinate for this region (where each co-ordinate is a Constants.RegionSize block).
+        /// </summary>
+        public uint X;
+
+        /// <summary>
+        /// The y co-ordinate for this region (where each cor-odinate is a Constants.RegionSize block).
+        /// </summary>
+        public uint Y;
+
+        /// <summary>
+        /// The X meters position of this connection.
+        /// </summary>
+        public uint PosX { get { return Util.RegionToWorldLoc(X); } }
+
+        /// <summary>
+        /// The Y meters co-ordinate of this connection.
+        /// </summary>
+        public uint PosY { get { return Util.RegionToWorldLoc(Y); } }
+
+        /// <summary>
+        /// The size of the megaregion in meters.
+        /// </summary>
+        public uint XEnd;
+
+        /// <summary>
+        /// The size of the megaregion in meters.
+        /// </summary>
+        public uint YEnd;
+
+        public List<RegionData> ConnectedRegions;
+        public RegionCombinerPermissionModule PermissionModule;
+        public RegionCombinerClientEventForwarder ClientEventForwarder;
+
+        public void UpdateExtents(Vector3 extents)
+        {
+            XEnd = (uint)extents.X;
+            YEnd = (uint)extents.Y;
+        }
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCourseLocation.cs b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCourseLocation.cs
new file mode 100644
index 0000000..224ac99
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionCourseLocation.cs
@@ -0,0 +1,43 @@
+/*
+ * 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 OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.RegionCombinerModule
+{
+
+    struct RegionCoarseLocationStruct
+    {
+        public List<Vector3> Locations;
+        public List<UUID> Uuids;
+        public IClientAPI UserAPI;
+        public Vector2 Offset;
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionData.cs b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionData.cs
new file mode 100644
index 0000000..42fca9f
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/RegionCombinerModule/RegionData.cs
@@ -0,0 +1,40 @@
+/*
+ * 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 OpenMetaverse;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.RegionCombinerModule
+{
+    public class RegionData
+    {
+        public UUID RegionId;
+        public Scene RegionScene;
+        // Offset of this region from the base of the root region.
+        public Vector3 Offset;
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/Scripting/ExtendedPhysics/ExtendedPhysics.cs b/OpenSim/Region/OptionalModules/Scripting/ExtendedPhysics/ExtendedPhysics.cs
deleted file mode 100755
index ff4afbf..0000000
--- a/OpenSim/Region/OptionalModules/Scripting/ExtendedPhysics/ExtendedPhysics.cs
+++ /dev/null
@@ -1,623 +0,0 @@
-/*
- * 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 copyrightD
- *       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.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading;
-
-using OpenSim.Framework;
-using OpenSim.Region.CoreModules;
-using OpenSim.Region.Framework;
-using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Physics.Manager;
-
-using Mono.Addins;
-using Nini.Config;
-using log4net;
-using OpenMetaverse;
-
-namespace OpenSim.Region.OptionalModules.Scripting
-{
-[Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
-public class ExtendedPhysics : INonSharedRegionModule
-{
-    private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-    private static string LogHeader = "[EXTENDED PHYSICS]";
-
-    // =============================================================
-    // Since BulletSim is a plugin, this these values aren't defined easily in one place.
-    // This table must correspond to an identical table in BSScene.
-
-    // Per scene functions. See BSScene.
-
-    // Per avatar functions. See BSCharacter.
-
-    // Per prim functions. See BSPrim.
-    public const string PhysFunctGetLinksetType = "BulletSim.GetLinksetType";
-    public const string PhysFunctSetLinksetType = "BulletSim.SetLinksetType";
-    public const string PhysFunctChangeLinkFixed = "BulletSim.ChangeLinkFixed";
-    public const string PhysFunctChangeLinkType = "BulletSim.ChangeLinkType";
-    public const string PhysFunctGetLinkType = "BulletSim.GetLinkType";
-    public const string PhysFunctChangeLinkParams = "BulletSim.ChangeLinkParams";
-    public const string PhysFunctAxisLockLimits = "BulletSim.AxisLockLimits";
-
-    // =============================================================
-
-    private IConfig Configuration { get; set; }
-    private bool Enabled { get; set; }
-    private Scene BaseScene { get; set; }
-    private IScriptModuleComms Comms { get; set; }
-
-    #region INonSharedRegionModule
-
-    public string Name { get { return this.GetType().Name; } }
-
-    public void Initialise(IConfigSource config)
-    {
-        BaseScene = null;
-        Enabled = false;
-        Configuration = null;
-        Comms = null;
-
-        try
-        {
-            if ((Configuration = config.Configs["ExtendedPhysics"]) != null)
-            {
-                Enabled = Configuration.GetBoolean("Enabled", Enabled);
-            }
-        }
-        catch (Exception e)
-        {
-            m_log.ErrorFormat("{0} Initialization error: {0}", LogHeader, e);
-        }
-
-        m_log.InfoFormat("{0} module {1} enabled", LogHeader, (Enabled ? "is" : "is not"));
-    }
-
-    public void Close()
-    {
-        if (BaseScene != null)
-        {
-            BaseScene.EventManager.OnObjectAddedToScene -= EventManager_OnObjectAddedToScene;
-            BaseScene.EventManager.OnSceneObjectPartUpdated -= EventManager_OnSceneObjectPartUpdated;
-            BaseScene = null;
-        }
-    }
-
-    public void AddRegion(Scene scene)
-    {
-    }
-
-    public void RemoveRegion(Scene scene)
-    {
-        if (BaseScene != null && BaseScene == scene)
-        {
-            Close();
-        }
-    }
-
-    public void RegionLoaded(Scene scene)
-    {
-        if (!Enabled) return;
-
-        BaseScene = scene;
-
-        Comms = BaseScene.RequestModuleInterface<IScriptModuleComms>();
-        if (Comms == null)
-        {
-            m_log.WarnFormat("{0} ScriptModuleComms interface not defined", LogHeader);
-            Enabled = false;
-
-            return;
-        }
- 
-        // Register as LSL functions all the [ScriptInvocation] marked methods.
-        Comms.RegisterScriptInvocations(this);
-        Comms.RegisterConstants(this);
-
-        // When an object is modified, we might need to update its extended physics parameters
-        BaseScene.EventManager.OnObjectAddedToScene += EventManager_OnObjectAddedToScene;
-        BaseScene.EventManager.OnSceneObjectPartUpdated += EventManager_OnSceneObjectPartUpdated;
-
-    }
-
-    public Type ReplaceableInterface { get { return null; } }
-
-    #endregion // INonSharedRegionModule
-
-    private void EventManager_OnObjectAddedToScene(SceneObjectGroup obj)
-    {
-    }
-
-    // Event generated when some property of a prim changes.
-    private void EventManager_OnSceneObjectPartUpdated(SceneObjectPart sop, bool isFullUpdate)
-    {
-    }
-
-    [ScriptConstant]
-    public const int PHYS_CENTER_OF_MASS =     1 << 0;
-
-    [ScriptInvocation]
-    public string physGetEngineType(UUID hostID, UUID scriptID)
-    {
-        string ret = string.Empty;
-
-        if (BaseScene.PhysicsScene != null)
-        {
-            ret = BaseScene.PhysicsScene.EngineType;
-        }
-
-        return ret;
-    }
-
-    // Code for specifying params.
-    // The choice if 14700 is arbitrary and only serves to catch parameter code misuse.
-    [ScriptConstant]
-    public const int PHYS_AXIS_LOCK_LINEAR     = 14700;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LOCK_LINEAR_X   = 14701;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LIMIT_LINEAR_X  = 14702;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LOCK_LINEAR_Y   = 14703;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LIMIT_LINEAR_Y  = 14704;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LOCK_LINEAR_Z   = 14705;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LIMIT_LINEAR_Z  = 14706;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LOCK_ANGULAR    = 14707;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LOCK_ANGULAR_X  = 14708;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LIMIT_ANGULAR_X = 14709;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LOCK_ANGULAR_Y  = 14710;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LIMIT_ANGULAR_Y = 14711;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LOCK_ANGULAR_Z  = 14712;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LIMIT_ANGULAR_Z = 14713;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK_LINEAR   = 14714;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK_LINEAR_X = 14715;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK_LINEAR_Y = 14716;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK_LINEAR_Z = 14717;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK_ANGULAR  = 14718;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK_ANGULAR_X = 14719;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK_ANGULAR_Y = 14720;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK_ANGULAR_Z = 14721;
-    [ScriptConstant]
-    public const int PHYS_AXIS_UNLOCK           = 14722;
-    // physAxisLockLimits()
-    [ScriptInvocation]
-    public int physAxisLock(UUID hostID, UUID scriptID, object[] parms)
-    {
-        int ret = -1;
-        if (!Enabled) return ret;
-
-        PhysicsActor rootPhysActor;
-        if (GetRootPhysActor(hostID, out rootPhysActor))
-        {
-            object[] parms2 = AddToBeginningOfArray(rootPhysActor, null, parms);
-            ret = MakeIntError(rootPhysActor.Extension(PhysFunctAxisLockLimits, parms2));
-        }
-
-        return ret;
-    }
-
-    [ScriptConstant]
-    public const int PHYS_LINKSET_TYPE_CONSTRAINT  = 0;
-    [ScriptConstant]
-    public const int PHYS_LINKSET_TYPE_COMPOUND    = 1;
-    [ScriptConstant]
-    public const int PHYS_LINKSET_TYPE_MANUAL      = 2;
-
-    [ScriptInvocation]
-    public int physSetLinksetType(UUID hostID, UUID scriptID, int linksetType)
-    {
-        int ret = -1;
-        if (!Enabled) return ret;
-
-        // The part that is requesting the change.
-        SceneObjectPart requestingPart = BaseScene.GetSceneObjectPart(hostID);
-
-        if (requestingPart != null)
-        {
-            // The change is always made to the root of a linkset.
-            SceneObjectGroup containingGroup = requestingPart.ParentGroup;
-            SceneObjectPart rootPart = containingGroup.RootPart;
-
-            if (rootPart != null)
-            {
-                PhysicsActor rootPhysActor = rootPart.PhysActor;
-                if (rootPhysActor != null)
-                {
-                    if (rootPhysActor.IsPhysical)
-                    {
-                        // Change a physical linkset by making non-physical, waiting for one heartbeat so all
-                        //    the prim and linkset state is updated, changing the type and making the
-                        //    linkset physical again.
-                        containingGroup.ScriptSetPhysicsStatus(false);
-                        Thread.Sleep(150);  // longer than one heartbeat tick
-
-                        // A kludge for the moment.
-                        // Since compound linksets move the children but don't generate position updates to the
-                        //     simulator, it is possible for compound linkset children to have out-of-sync simulator
-                        //     and physical positions. The following causes the simulator to push the real child positions
-                        //     down into the physics engine to get everything synced.
-                        containingGroup.UpdateGroupPosition(containingGroup.AbsolutePosition);
-                        containingGroup.UpdateGroupRotationR(containingGroup.GroupRotation);
-
-                        object[] parms2 = { rootPhysActor, null, linksetType };
-                        ret = MakeIntError(rootPhysActor.Extension(PhysFunctSetLinksetType, parms2));
-                        Thread.Sleep(150);  // longer than one heartbeat tick
-
-                        containingGroup.ScriptSetPhysicsStatus(true);
-                    }
-                    else
-                    {
-                        // Non-physical linksets don't have a physical instantiation so there is no state to
-                        //    worry about being updated.
-                        object[] parms2 = { rootPhysActor, null, linksetType };
-                        ret = MakeIntError(rootPhysActor.Extension(PhysFunctSetLinksetType, parms2));
-                    }
-                }
-                else
-                {
-                    m_log.WarnFormat("{0} physSetLinksetType: root part does not have a physics actor. rootName={1}, hostID={2}",
-                                        LogHeader, rootPart.Name, hostID);
-                }
-            }
-            else
-            {
-                m_log.WarnFormat("{0} physSetLinksetType: root part does not exist. RequestingPartName={1}, hostID={2}",
-                                    LogHeader, requestingPart.Name, hostID);
-            }
-        }
-        else
-        {
-            m_log.WarnFormat("{0} physSetLinsetType: cannot find script object in scene. hostID={1}", LogHeader, hostID);
-        }
-        return ret;
-    }
-
-    [ScriptInvocation]
-    public int physGetLinksetType(UUID hostID, UUID scriptID)
-    {
-        int ret = -1;
-        if (!Enabled) return ret;
-
-        PhysicsActor rootPhysActor;
-        if (GetRootPhysActor(hostID, out rootPhysActor))
-        {
-            object[] parms2 = { rootPhysActor, null };
-            ret = MakeIntError(rootPhysActor.Extension(PhysFunctGetLinksetType, parms2));
-        }
-        else
-        {
-            m_log.WarnFormat("{0} physGetLinsetType: cannot find script object in scene. hostID={1}", LogHeader, hostID);
-        }
-        return ret;
-    }
-
-    [ScriptConstant]
-    public const int PHYS_LINK_TYPE_FIXED  = 1234;
-    [ScriptConstant]
-    public const int PHYS_LINK_TYPE_HINGE  = 4;
-    [ScriptConstant]
-    public const int PHYS_LINK_TYPE_SPRING = 9;
-    [ScriptConstant]
-    public const int PHYS_LINK_TYPE_6DOF   = 6;
-    [ScriptConstant]
-    public const int PHYS_LINK_TYPE_SLIDER = 7;
-
-    // physChangeLinkType(integer linkNum, integer typeCode)
-    [ScriptInvocation]
-    public int physChangeLinkType(UUID hostID, UUID scriptID, int linkNum, int typeCode)
-    {
-        int ret = -1;
-        if (!Enabled) return ret;
-
-        PhysicsActor rootPhysActor;
-        PhysicsActor childPhysActor;
-
-        if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
-        {
-            object[] parms2 = { rootPhysActor, childPhysActor, typeCode };
-            ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkType, parms2));
-        }
-
-        return ret;
-    }
-
-    // physGetLinkType(integer linkNum)
-    [ScriptInvocation]
-    public int physGetLinkType(UUID hostID, UUID scriptID, int linkNum)
-    {
-        int ret = -1;
-        if (!Enabled) return ret;
-
-        PhysicsActor rootPhysActor;
-        PhysicsActor childPhysActor;
-
-        if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
-        {
-            object[] parms2 = { rootPhysActor, childPhysActor };
-            ret = MakeIntError(rootPhysActor.Extension(PhysFunctGetLinkType, parms2));
-        }
-
-        return ret;
-    }
-
-    // physChangeLinkFixed(integer linkNum)
-    // Change the link between the root and the linkNum into a fixed, static physical connection.
-    [ScriptInvocation]
-    public int physChangeLinkFixed(UUID hostID, UUID scriptID, int linkNum)
-    {
-        int ret = -1;
-        if (!Enabled) return ret;
-
-        PhysicsActor rootPhysActor;
-        PhysicsActor childPhysActor;
-
-        if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
-        {
-            object[] parms2 = { rootPhysActor, childPhysActor , PHYS_LINK_TYPE_FIXED };
-            ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkType, parms2));
-        }
-
-        return ret;
-    }
-
-    // Code for specifying params.
-    // The choice if 14400 is arbitrary and only serves to catch parameter code misuse.
-    public const int PHYS_PARAM_MIN                    = 14401;
-
-    [ScriptConstant]
-    public const int PHYS_PARAM_FRAMEINA_LOC           = 14401;
-    [ScriptConstant]
-    public const int PHYS_PARAM_FRAMEINA_ROT           = 14402;
-    [ScriptConstant]
-    public const int PHYS_PARAM_FRAMEINB_LOC           = 14403;
-    [ScriptConstant]
-    public const int PHYS_PARAM_FRAMEINB_ROT           = 14404;
-    [ScriptConstant]
-    public const int PHYS_PARAM_LINEAR_LIMIT_LOW       = 14405;
-    [ScriptConstant]
-    public const int PHYS_PARAM_LINEAR_LIMIT_HIGH      = 14406;
-    [ScriptConstant]
-    public const int PHYS_PARAM_ANGULAR_LIMIT_LOW      = 14407;
-    [ScriptConstant]
-    public const int PHYS_PARAM_ANGULAR_LIMIT_HIGH     = 14408;
-    [ScriptConstant]
-    public const int PHYS_PARAM_USE_FRAME_OFFSET       = 14409;
-    [ScriptConstant]
-    public const int PHYS_PARAM_ENABLE_TRANSMOTOR      = 14410;
-    [ScriptConstant]
-    public const int PHYS_PARAM_TRANSMOTOR_MAXVEL      = 14411;
-    [ScriptConstant]
-    public const int PHYS_PARAM_TRANSMOTOR_MAXFORCE    = 14412;
-    [ScriptConstant]
-    public const int PHYS_PARAM_CFM                    = 14413;
-    [ScriptConstant]
-    public const int PHYS_PARAM_ERP                    = 14414;
-    [ScriptConstant]
-    public const int PHYS_PARAM_SOLVER_ITERATIONS      = 14415;
-    [ScriptConstant]
-    public const int PHYS_PARAM_SPRING_AXIS_ENABLE     = 14416;
-    [ScriptConstant]
-    public const int PHYS_PARAM_SPRING_DAMPING         = 14417;
-    [ScriptConstant]
-    public const int PHYS_PARAM_SPRING_STIFFNESS       = 14418;
-    [ScriptConstant]
-    public const int PHYS_PARAM_LINK_TYPE              = 14419;
-    [ScriptConstant]
-    public const int PHYS_PARAM_USE_LINEAR_FRAMEA      = 14420;
-    [ScriptConstant]
-    public const int PHYS_PARAM_SPRING_EQUILIBRIUM_POINT = 14421;
-
-    public const int PHYS_PARAM_MAX                    = 14421;
-
-    // Used when specifying a parameter that has settings for the three linear and three angular axis
-    [ScriptConstant]
-    public const int PHYS_AXIS_ALL = -1;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LINEAR_ALL = -2;
-    [ScriptConstant]
-    public const int PHYS_AXIS_ANGULAR_ALL = -3;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LINEAR_X  = 0;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LINEAR_Y  = 1;
-    [ScriptConstant]
-    public const int PHYS_AXIS_LINEAR_Z  = 2;
-    [ScriptConstant]
-    public const int PHYS_AXIS_ANGULAR_X = 3;
-    [ScriptConstant]
-    public const int PHYS_AXIS_ANGULAR_Y = 4;
-    [ScriptConstant]
-    public const int PHYS_AXIS_ANGULAR_Z = 5;
-
-    // physChangeLinkParams(integer linkNum, [ PHYS_PARAM_*, value, PHYS_PARAM_*, value, ...])
-    [ScriptInvocation]
-    public int physChangeLinkParams(UUID hostID, UUID scriptID, int linkNum, object[] parms)
-    {
-        int ret = -1;
-        if (!Enabled) return ret;
-
-        PhysicsActor rootPhysActor;
-        PhysicsActor childPhysActor;
-
-        if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
-        {
-            object[] parms2 = AddToBeginningOfArray(rootPhysActor, childPhysActor, parms);
-            ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkParams, parms2));
-        }
-
-        return ret;
-    }
-
-    private bool GetRootPhysActor(UUID hostID, out PhysicsActor rootPhysActor)
-    {
-        SceneObjectGroup containingGroup;
-        SceneObjectPart rootPart;
-        return GetRootPhysActor(hostID, out containingGroup, out rootPart, out rootPhysActor);
-    }
-
-    private bool GetRootPhysActor(UUID hostID, out SceneObjectGroup containingGroup, out SceneObjectPart rootPart, out PhysicsActor rootPhysActor)
-    {
-        bool ret = false;
-        rootPhysActor = null;
-        containingGroup = null;
-        rootPart = null;
-
-        SceneObjectPart requestingPart;
-
-        requestingPart = BaseScene.GetSceneObjectPart(hostID);
-        if (requestingPart != null)
-        {
-            // The type is is always on the root of a linkset.
-            containingGroup = requestingPart.ParentGroup;
-            if (containingGroup != null && !containingGroup.IsDeleted)
-            {
-                rootPart = containingGroup.RootPart;
-                if (rootPart != null)
-                {
-                    rootPhysActor = rootPart.PhysActor;
-                    if (rootPhysActor != null)
-                    {
-                        ret = true;
-                    }
-                    else
-                    {
-                        m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not have a physics actor. rootName={1}, hostID={2}",
-                                        LogHeader, rootPart.Name, hostID);
-                    }
-                }
-                else
-                {
-                    m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not exist. RequestingPartName={1}, hostID={2}",
-                                    LogHeader, requestingPart.Name, hostID);
-                }
-            }
-            else
-            {
-                m_log.WarnFormat("{0} GetRootAndChildPhysActors: Containing group missing or deleted. hostID={1}", LogHeader, hostID);
-            }
-        }
-        else
-        {
-            m_log.WarnFormat("{0} GetRootAndChildPhysActors: cannot find script object in scene. hostID={1}", LogHeader, hostID);
-        }
-
-        return ret;
-    }
-
-    // Find the root and child PhysActors based on the linkNum.
-    // Return 'true' if both are found and returned.
-    private bool GetRootAndChildPhysActors(UUID hostID, int linkNum, out PhysicsActor rootPhysActor, out PhysicsActor childPhysActor)
-    {
-        bool ret = false;
-        rootPhysActor = null;
-        childPhysActor = null;
-
-        SceneObjectGroup containingGroup;
-        SceneObjectPart rootPart;
-
-        if (GetRootPhysActor(hostID, out containingGroup, out rootPart, out rootPhysActor))
-        {
-            SceneObjectPart linkPart = containingGroup.GetLinkNumPart(linkNum);
-            if (linkPart != null)
-            {
-                childPhysActor = linkPart.PhysActor;
-                if (childPhysActor != null)
-                {
-                    ret = true;
-                }
-                else
-                {
-                    m_log.WarnFormat("{0} GetRootAndChildPhysActors: Link part has no physical actor. rootName={1}, hostID={2}, linknum={3}",
-                                        LogHeader, rootPart.Name, hostID, linkNum);
-                }
-            }
-            else
-            {
-                m_log.WarnFormat("{0} GetRootAndChildPhysActors: Could not find linknum part. rootName={1}, hostID={2}, linknum={3}",
-                                    LogHeader, rootPart.Name, hostID, linkNum);
-            }
-        }
-        else
-        {
-            m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not have a physics actor. rootName={1}, hostID={2}",
-                            LogHeader, rootPart.Name, hostID);
-        }
-
-        return ret;
-    }
-
-    // Return an array of objects with the passed object as the first object of a new array
-    private object[] AddToBeginningOfArray(object firstOne, object secondOne, object[] prevArray)
-    {
-        object[] newArray = new object[2 + prevArray.Length];
-        newArray[0] = firstOne;
-        newArray[1] = secondOne;
-        prevArray.CopyTo(newArray, 2);
-        return newArray;
-    }
-
-    // Extension() returns an object. Convert that object into the integer error we expect to return.
-    private int MakeIntError(object extensionRet)
-    {
-        int ret = -1;
-        if (extensionRet != null)
-        {
-            try
-            {
-                ret = (int)extensionRet;
-            }
-            catch
-            {
-                ret = -1;
-            }
-        }
-        return ret;
-    }
-}
-}
diff --git a/OpenSim/Region/OptionalModules/Scripting/Minimodule/SOPObject.cs b/OpenSim/Region/OptionalModules/Scripting/Minimodule/SOPObject.cs
index 5ed1514..47b9c09 100644
--- a/OpenSim/Region/OptionalModules/Scripting/Minimodule/SOPObject.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/Minimodule/SOPObject.cs
@@ -34,7 +34,7 @@ using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.OptionalModules.Scripting.Minimodule.Object;
-using OpenSim.Region.Physics.Manager;
+using OpenSim.Region.PhysicsModules.SharedBase;
 using PrimType=OpenSim.Region.OptionalModules.Scripting.Minimodule.Object.PrimType;
 using SculptType=OpenSim.Region.OptionalModules.Scripting.Minimodule.Object.SculptType;
 
diff --git a/OpenSim/Region/OptionalModules/Scripting/XmlRpcRouterModule/XmlRpcGridRouterModule.cs b/OpenSim/Region/OptionalModules/Scripting/XmlRpcRouterModule/XmlRpcGridRouterModule.cs
index 97133c0..4b7295d 100644
--- a/OpenSim/Region/OptionalModules/Scripting/XmlRpcRouterModule/XmlRpcGridRouterModule.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/XmlRpcRouterModule/XmlRpcGridRouterModule.cs
@@ -35,7 +35,6 @@ using OpenMetaverse;
 using Mono.Addins;
 
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Framework.Client;
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/ActiveConnectionsAJAX.cs b/OpenSim/Region/OptionalModules/UserStatistics/ActiveConnectionsAJAX.cs
new file mode 100644
index 0000000..6a1112c
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/ActiveConnectionsAJAX.cs
@@ -0,0 +1,308 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class ActiveConnectionsAJAX : IStatsController
+    {
+        private Vector3 DefaultNeighborPosition = new Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 70);
+
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            List<Scene> m_scene = (List<Scene>)pParams["Scenes"];
+
+            Hashtable nh = new Hashtable();
+            nh.Add("hdata", m_scene);
+
+            return nh;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            List<Scene> all_scenes = (List<Scene>) pModelResult["hdata"];
+
+            StringBuilder output = new StringBuilder();
+            HTMLUtil.OL_O(ref output, "");
+            foreach (Scene scene in all_scenes)
+            {
+                HTMLUtil.LI_O(ref output, String.Empty);
+                output.Append(scene.RegionInfo.RegionName);
+                HTMLUtil.OL_O(ref output, String.Empty);
+                scene.ForEachScenePresence(delegate(ScenePresence av)
+                {
+                    Dictionary<string, string> queues = new Dictionary<string, string>();
+                    if (av.ControllingClient is IStatsCollector)
+                    {
+                        IStatsCollector isClient = (IStatsCollector)av.ControllingClient;
+                        queues = decodeQueueReport(isClient.Report());
+                    }
+                    HTMLUtil.LI_O(ref output, String.Empty);
+                    output.Append(av.Name);
+                    output.Append("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
+                    output.Append((av.IsChildAgent ? "Child" : "Root"));
+                    if (av.AbsolutePosition == DefaultNeighborPosition)
+                    {
+                        output.Append("<br />Position: ?");
+                    }
+                    else
+                    {
+                        output.Append(string.Format("<br /><NOBR>Position: <{0},{1},{2}></NOBR>", (int)av.AbsolutePosition.X,
+                                                    (int)av.AbsolutePosition.Y,
+                                                    (int)av.AbsolutePosition.Z));
+                    }
+                    Dictionary<string, int> throttles = DecodeClientThrottles(av.ControllingClient.GetThrottlesPacked(1));
+
+                    HTMLUtil.UL_O(ref output, String.Empty);
+
+                    foreach (string throttlename in throttles.Keys)
+                    {
+                        HTMLUtil.LI_O(ref output, String.Empty);
+                        output.Append(throttlename);
+                        output.Append(":");
+                        output.Append(throttles[throttlename].ToString());
+                        if (queues.ContainsKey(throttlename))
+                        {
+                            output.Append("/");
+                            output.Append(queues[throttlename]);
+                        }
+                        HTMLUtil.LI_C(ref output);
+                    }
+                    if (queues.ContainsKey("Incoming") && queues.ContainsKey("Outgoing"))
+                    {
+                        HTMLUtil.LI_O(ref output, "red");
+                        output.Append("SEND:");
+                        output.Append(queues["Outgoing"]);
+                        output.Append("/");
+                        output.Append(queues["Incoming"]);
+                        HTMLUtil.LI_C(ref output);
+                    }
+
+                    HTMLUtil.UL_C(ref output);
+                    HTMLUtil.LI_C(ref output);
+                });
+                HTMLUtil.OL_C(ref output);
+            }
+            HTMLUtil.OL_C(ref output);
+            return output.ToString();
+        }
+
+        /// <summary>
+        /// Convert active connections information to JSON string. Returns a structure:
+        /// <pre>
+        /// {"regionName": {
+        ///     "presenceName": {
+        ///         "name": "presenceName",
+        ///         "position": "<x,y,z>",
+        ///         "isRoot": "false",
+        ///         "throttle": {
+        ///         },
+        ///         "queue": {
+        ///         }
+        ///     },
+        ///     ... // multiple presences in the scene
+        ///   },
+        ///   ...   // multiple regions in the sim
+        /// }
+        ///
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult)
+        {
+            List<Scene> all_scenes = (List<Scene>) pModelResult["hdata"];
+
+            OSDMap regionInfo = new OSDMap();
+            foreach (Scene scene in all_scenes)
+            {
+                OSDMap sceneInfo = new OpenMetaverse.StructuredData.OSDMap();
+                List<ScenePresence> avatarInScene = scene.GetScenePresences();
+                foreach (ScenePresence av in avatarInScene)
+                {
+                    OSDMap presenceInfo = new OSDMap();
+                    presenceInfo.Add("Name", new OSDString(av.Name));
+
+                    Dictionary<string,string> queues = new Dictionary<string, string>();
+                    if (av.ControllingClient is IStatsCollector)
+                    {
+                        IStatsCollector isClient = (IStatsCollector) av.ControllingClient;
+                        queues = decodeQueueReport(isClient.Report());
+                    }
+                    OSDMap queueInfo = new OpenMetaverse.StructuredData.OSDMap();
+                    foreach (KeyValuePair<string, string> kvp in queues) {
+                        queueInfo.Add(kvp.Key, new OSDString(kvp.Value));
+                    }
+                    sceneInfo.Add("queues", queueInfo);
+
+                    if (av.IsChildAgent)
+                        presenceInfo.Add("isRoot", new OSDString("false"));
+                    else
+                        presenceInfo.Add("isRoot", new OSDString("true"));
+
+                    if (av.AbsolutePosition == DefaultNeighborPosition)
+                    {
+                        presenceInfo.Add("position", new OSDString("<0, 0, 0>"));
+                    }
+                    else
+                    {
+                        presenceInfo.Add("position", new OSDString(string.Format("<{0},{1},{2}>",
+                                                    (int)av.AbsolutePosition.X,
+                                                    (int) av.AbsolutePosition.Y,
+                                                    (int) av.AbsolutePosition.Z)) );
+                    }
+
+                    Dictionary<string, int> throttles = DecodeClientThrottles(av.ControllingClient.GetThrottlesPacked(1));
+                    OSDMap throttleInfo = new OpenMetaverse.StructuredData.OSDMap();
+                    foreach (string throttlename in throttles.Keys)
+                    {
+                        throttleInfo.Add(throttlename, new OSDString(throttles[throttlename].ToString()));
+                    }
+                    presenceInfo.Add("throttle", throttleInfo);
+
+                    sceneInfo.Add(av.Name, presenceInfo);
+                }
+                regionInfo.Add(scene.RegionInfo.RegionName, sceneInfo);
+            }
+            return regionInfo.ToString();
+        }
+
+        public Dictionary<string, int> DecodeClientThrottles(byte[] throttle)
+        {
+            Dictionary<string, int> returndict = new Dictionary<string, int>();
+            // From mantis http://opensimulator.org/mantis/view.php?id=1374
+            // it appears that sometimes we are receiving empty throttle byte arrays.
+            // TODO: Investigate this behaviour
+            if (throttle.Length == 0)
+            {
+                return new Dictionary<string, int>();
+            }
+
+            int tResend = -1;
+            int tLand = -1;
+            int tWind = -1;
+            int tCloud = -1;
+            int tTask = -1;
+            int tTexture = -1;
+            int tAsset = -1;
+            int tall = -1;
+            const int singlefloat = 4;
+
+            //Agent Throttle Block contains 7 single floatingpoint values.
+            int j = 0;
+
+            // Some Systems may be big endian...
+            // it might be smart to do this check more often...
+            if (!BitConverter.IsLittleEndian)
+                for (int i = 0; i < 7; i++)
+                    Array.Reverse(throttle, j + i * singlefloat, singlefloat);
+
+            // values gotten from OpenMetaverse.org/wiki/Throttle.  Thanks MW_
+            // bytes
+            // Convert to integer, since..   the full fp space isn't used.
+            tResend = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Resend", tResend);
+            j += singlefloat;
+            tLand = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Land", tLand);
+            j += singlefloat;
+            tWind = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Wind", tWind);
+            j += singlefloat;
+            tCloud = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Cloud", tCloud);
+            j += singlefloat;
+            tTask = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Task", tTask);
+            j += singlefloat;
+            tTexture = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Texture", tTexture);
+            j += singlefloat;
+            tAsset = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Asset", tAsset);
+
+            tall = tResend + tLand + tWind + tCloud + tTask + tTexture + tAsset;
+            returndict.Add("All", tall);
+
+            return returndict;
+        }
+        public Dictionary<string,string> decodeQueueReport(string rep)
+        {
+            Dictionary<string, string> returndic = new Dictionary<string, string>();
+            if (rep.Length == 79)
+            {
+                int pos = 1;
+                returndic.Add("All", rep.Substring((6 * pos), 8)); pos++;
+                returndic.Add("Incoming", rep.Substring((7 * pos), 8)); pos++;
+                returndic.Add("Outgoing", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Resend", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Land", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Wind", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Cloud", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Task", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Texture", rep.Substring((7 * pos), 8)); pos++;
+                returndic.Add("Asset", rep.Substring((7 * pos), 8));
+                /*
+                 * return string.Format("{0,7} {1,7} {2,7} {3,7} {4,7} {5,7} {6,7} {7,7} {8,7} {9,7}",
+                                 SendQueue.Count(),
+                                 IncomingPacketQueue.Count,
+                                 OutgoingPacketQueue.Count,
+                                 ResendOutgoingPacketQueue.Count,
+                                 LandOutgoingPacketQueue.Count,
+                                 WindOutgoingPacketQueue.Count,
+                                 CloudOutgoingPacketQueue.Count,
+                                 TaskOutgoingPacketQueue.Count,
+                                 TextureOutgoingPacketQueue.Count,
+                                 AssetOutgoingPacketQueue.Count);
+                 */
+            }
+
+
+
+            return returndic;
+        }
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Clients_report.cs b/OpenSim/Region/OptionalModules/UserStatistics/Clients_report.cs
new file mode 100644
index 0000000..4a6f7be
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Clients_report.cs
@@ -0,0 +1,329 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Clients_report : IStatsController
+    {
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return "Client"; }
+        }
+
+        /// <summary>
+        /// Return summar information in the form:
+        /// <pre>
+        /// {"totalUsers": "34",
+        ///  "totalSessions": "233",
+        ///  ...
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult) {
+            stats_default_page_values values = (stats_default_page_values) pModelResult["hdata"];
+
+            OSDMap summaryInfo = new OpenMetaverse.StructuredData.OSDMap();
+            summaryInfo.Add("totalUsers", new OSDString(values.total_num_users.ToString()));
+            summaryInfo.Add("totalSessions", new OSDString(values.total_num_sessions.ToString()));
+            summaryInfo.Add("averageClientFPS", new OSDString(values.avg_client_fps.ToString()));
+            summaryInfo.Add("averageClientMem", new OSDString(values.avg_client_mem_use.ToString()));
+            summaryInfo.Add("averageSimFPS", new OSDString(values.avg_sim_fps.ToString()));
+            summaryInfo.Add("averagePingTime", new OSDString(values.avg_ping.ToString()));
+            summaryInfo.Add("totalKBOut", new OSDString(values.total_kb_out.ToString()));
+            summaryInfo.Add("totalKBIn", new OSDString(values.total_kb_in.ToString()));
+            return summaryInfo.ToString();
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            SqliteConnection dbConn = (SqliteConnection)pParams["DatabaseConnection"];
+
+
+            List<ClientVersionData> clidata = new List<ClientVersionData>();
+            List<ClientVersionData> cliRegData = new List<ClientVersionData>();
+            Hashtable regionTotals = new Hashtable();
+
+            Hashtable modeldata = new Hashtable();
+            modeldata.Add("Scenes", pParams["Scenes"]);
+            modeldata.Add("Reports", pParams["Reports"]);
+            int totalclients = 0;
+            int totalregions = 0;
+
+            lock (dbConn)
+            {
+                string sql = "select count(distinct region_id) as regcnt from stats_session_data";
+
+                SqliteCommand cmd = new SqliteCommand(sql, dbConn);
+                SqliteDataReader sdr = cmd.ExecuteReader();
+                if (sdr.HasRows)
+                {
+                    sdr.Read();
+                    totalregions = Convert.ToInt32(sdr["regcnt"]);
+                }
+
+                sdr.Close();
+                sdr.Dispose();
+
+                sql =
+                    "select client_version, count(*) as cnt, avg(avg_sim_fps) as simfps from stats_session_data group by client_version order by count(*) desc LIMIT 10;";
+
+                cmd = new SqliteCommand(sql, dbConn);
+                sdr = cmd.ExecuteReader();
+                if (sdr.HasRows)
+                {
+                    while (sdr.Read())
+                    {
+                        ClientVersionData udata = new ClientVersionData();
+                        udata.version = sdr["client_version"].ToString();
+                        udata.count = Convert.ToInt32(sdr["cnt"]);
+                        udata.fps = Convert.ToSingle(sdr["simfps"]);
+                        clidata.Add(udata);
+                        totalclients += udata.count;
+                        
+                    }
+                }
+                sdr.Close();
+                sdr.Dispose();
+
+                if (totalregions > 1)
+                {
+                    sql =
+                        "select region_id, client_version, count(*) as cnt, avg(avg_sim_fps) as simfps from stats_session_data group by region_id, client_version order by region_id, count(*) desc;";
+                    cmd = new SqliteCommand(sql, dbConn);
+                    
+                    sdr = cmd.ExecuteReader();
+                    
+                    if (sdr.HasRows)
+                    {
+                        while (sdr.Read())
+                        {
+                            ClientVersionData udata = new ClientVersionData();
+                            udata.version = sdr["client_version"].ToString();
+                            udata.count = Convert.ToInt32(sdr["cnt"]);
+                            udata.fps = Convert.ToSingle(sdr["simfps"]);
+                            udata.region_id = UUID.Parse(sdr["region_id"].ToString());
+                            cliRegData.Add(udata);
+                        }
+                    }
+                    sdr.Close();
+                    sdr.Dispose();
+
+
+                }
+
+            }
+            
+            foreach (ClientVersionData cvd in cliRegData)
+            {
+                
+                if (regionTotals.ContainsKey(cvd.region_id))
+                {
+                    int regiontotal = (int)regionTotals[cvd.region_id];
+                    regiontotal += cvd.count;
+                    regionTotals[cvd.region_id] = regiontotal;
+                }
+                else
+                {
+                    regionTotals.Add(cvd.region_id, cvd.count);
+                }
+                
+                
+
+            }
+
+            modeldata["ClientData"] = clidata;
+            modeldata["ClientRegionData"] = cliRegData;
+            modeldata["RegionTotals"] = regionTotals;
+            modeldata["Total"] = totalclients;
+
+            return modeldata;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            List<ClientVersionData> clidata = (List<ClientVersionData>) pModelResult["ClientData"];
+            int totalclients = (int)pModelResult["Total"];
+            Hashtable regionTotals = (Hashtable) pModelResult["RegionTotals"];
+            List<ClientVersionData> cliRegData = (List<ClientVersionData>) pModelResult["ClientRegionData"];
+            List<Scene> m_scenes = (List<Scene>)pModelResult["Scenes"];
+            Dictionary<string, IStatsController> reports = (Dictionary<string, IStatsController>)pModelResult["Reports"];
+
+            const string STYLESHEET =
+    @"
+<STYLE>
+body
+{
+    font-size:15px; font-family:Helvetica, Verdana; color:Black;
+}
+TABLE.defaultr { }
+TR.defaultr { padding: 5px; }
+TD.header { font-weight:bold; padding:5px; }
+TD.content {}
+TD.contentright { text-align: right; }
+TD.contentcenter { text-align: center; }
+TD.align_top { vertical-align: top; }
+</STYLE>
+";
+
+            StringBuilder output = new StringBuilder();
+            HTMLUtil.HtmlHeaders_O(ref output);
+            output.Append(STYLESHEET);
+            HTMLUtil.HtmlHeaders_C(ref output);
+
+            HTMLUtil.AddReportLinks(ref output, reports, "");
+
+            HTMLUtil.TABLE_O(ref output, "defaultr");
+            HTMLUtil.TR_O(ref output, "");
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("ClientVersion");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("Count/%");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("SimFPS");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+
+            foreach (ClientVersionData cvd in clidata)
+            {
+                HTMLUtil.TR_O(ref output, "");
+                HTMLUtil.TD_O(ref output, "content");
+                string linkhref = "sessions.report?VersionString=" + cvd.version;
+                HTMLUtil.A(ref output, cvd.version, linkhref, "");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "content");
+                output.Append(cvd.count);
+                output.Append("/");
+                if (totalclients > 0)
+                    output.Append((((float)cvd.count / (float)totalclients)*100).ToString());
+                else
+                    output.Append(0);
+
+                output.Append("%");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "content");
+                output.Append(cvd.fps);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+            }
+            HTMLUtil.TABLE_C(ref output);
+
+            if (cliRegData.Count > 0)
+            {
+                HTMLUtil.TABLE_O(ref output, "defaultr");
+                HTMLUtil.TR_O(ref output, "");
+                HTMLUtil.TD_O(ref output, "header");
+                output.Append("Region");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "header");
+                output.Append("ClientVersion");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "header");
+                output.Append("Count/%");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "header");
+                output.Append("SimFPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+
+                foreach (ClientVersionData cvd in cliRegData)
+                {
+                    HTMLUtil.TR_O(ref output, "");
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(regionNamefromUUID(m_scenes, cvd.region_id));
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(cvd.version);
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(cvd.count);
+                    output.Append("/");
+                    if ((int)regionTotals[cvd.region_id] > 0)
+                        output.Append((((float)cvd.count / (float)((int)regionTotals[cvd.region_id])) * 100).ToString());
+                    else
+                        output.Append(0);
+
+                    output.Append("%");
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(cvd.fps);
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TR_C(ref output);
+                }
+                HTMLUtil.TABLE_C(ref output);
+
+            }
+
+            output.Append("</BODY>");
+            output.Append("</HTML>");
+            return output.ToString();
+        }
+        public string regionNamefromUUID(List<Scene> scenes, UUID region_id)
+        {
+            string returnstring = string.Empty;
+            foreach (Scene sn in scenes)
+            {
+                if (region_id == sn.RegionInfo.originRegionID)
+                {
+                    returnstring = sn.RegionInfo.RegionName;
+                    break;
+                }
+            }
+
+            if (returnstring.Length == 0)
+            {
+                returnstring = region_id.ToString();
+            }
+
+            return returnstring;
+        }
+
+        #endregion
+    }
+
+    public struct ClientVersionData
+    {
+        public UUID region_id;
+        public string version;
+        public int count;
+        public float fps;
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Default_Report.cs b/OpenSim/Region/OptionalModules/UserStatistics/Default_Report.cs
new file mode 100644
index 0000000..fabe3d4
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Default_Report.cs
@@ -0,0 +1,277 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Monitoring;
+
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Default_Report : IStatsController
+    {
+
+        public string ReportName
+        {
+            get { return "Home"; }
+        }
+
+        #region IStatsController Members
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            SqliteConnection conn = (SqliteConnection)pParams["DatabaseConnection"];
+            List<Scene> m_scene = (List<Scene>)pParams["Scenes"];
+
+            stats_default_page_values mData = rep_DefaultReport_data(conn, m_scene);
+            mData.sim_stat_data = (Dictionary<UUID,USimStatsData>)pParams["SimStats"];
+            mData.stats_reports = (Dictionary<string, IStatsController>) pParams["Reports"];
+
+            Hashtable nh = new Hashtable();
+            nh.Add("hdata", mData);
+            nh.Add("Reports", pParams["Reports"]);
+            
+            return nh;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            stats_default_page_values mData = (stats_default_page_values) pModelResult["hdata"];
+            return rep_Default_report_view(mData);
+        }
+
+        #endregion
+
+        public string rep_Default_report_view(stats_default_page_values values)
+        {
+
+            
+            StringBuilder output = new StringBuilder();
+
+
+
+            const string TableClass = "defaultr";
+            const string TRClass = "defaultr";
+            const string TDHeaderClass = "header";
+            const string TDDataClass = "content";
+            //const string TDDataClassRight = "contentright";
+            const string TDDataClassCenter = "contentcenter";
+
+            const string STYLESHEET =
+                @"
+<STYLE>
+body
+{
+    font-size:15px; font-family:Helvetica, Verdana; color:Black;
+}
+TABLE.defaultr { }
+TR.defaultr { padding: 5px; }
+TD.header { font-weight:bold; padding:5px; }
+TD.content {}
+TD.contentright { text-align: right; }
+TD.contentcenter { text-align: center; }
+TD.align_top { vertical-align: top; }
+</STYLE>
+";
+            HTMLUtil.HtmlHeaders_O(ref output);
+            
+            HTMLUtil.InsertProtoTypeAJAX(ref output);
+            string[] ajaxUpdaterDivs = new string[3];
+            int[] ajaxUpdaterSeconds = new int[3];
+            string[] ajaxUpdaterReportFragments = new string[3];
+
+            ajaxUpdaterDivs[0] = "activeconnections";
+            ajaxUpdaterSeconds[0] = 10;
+            ajaxUpdaterReportFragments[0] = "activeconnectionsajax.html";
+
+            ajaxUpdaterDivs[1] = "activesimstats";
+            ajaxUpdaterSeconds[1] = 20;
+            ajaxUpdaterReportFragments[1] = "simstatsajax.html";
+
+            ajaxUpdaterDivs[2] = "activelog";
+            ajaxUpdaterSeconds[2] = 5;
+            ajaxUpdaterReportFragments[2] = "activelogajax.html";
+
+            HTMLUtil.InsertPeriodicUpdaters(ref output, ajaxUpdaterDivs, ajaxUpdaterSeconds, ajaxUpdaterReportFragments);
+            
+            output.Append(STYLESHEET);
+            HTMLUtil.HtmlHeaders_C(ref output);
+            HTMLUtil.AddReportLinks(ref output, values.stats_reports, "");
+            HTMLUtil.TABLE_O(ref output, TableClass);
+            HTMLUtil.TR_O(ref output, TRClass);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("# Users Total");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("# Sessions Total");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("Avg Client FPS");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("Avg Client Mem Use");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("Avg Sim FPS");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("Avg Ping");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("KB Out Total");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("KB In Total");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+            HTMLUtil.TR_O(ref output, TRClass);
+            HTMLUtil.TD_O(ref output, TDDataClass);
+            output.Append(values.total_num_users);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClass);
+            output.Append(values.total_num_sessions);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.avg_client_fps);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.avg_client_mem_use);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.avg_sim_fps);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.avg_ping);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.total_kb_out);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.total_kb_in);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+            HTMLUtil.TABLE_C(ref output);
+
+            HTMLUtil.HR(ref output, "");
+            HTMLUtil.TABLE_O(ref output, "");
+            HTMLUtil.TR_O(ref output, "");
+            HTMLUtil.TD_O(ref output, "align_top");
+            output.Append("<DIV id=\"activeconnections\">Active Connections loading...</DIV>");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "align_top");
+            output.Append("<DIV id=\"activesimstats\">SimStats loading...</DIV>");
+            output.Append("<DIV id=\"activelog\">ActiveLog loading...</DIV>");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+            HTMLUtil.TABLE_C(ref output);
+            output.Append("</BODY></HTML>");
+            // TODO: FIXME: template
+            return output.ToString();
+        }
+
+       
+
+        public stats_default_page_values rep_DefaultReport_data(SqliteConnection db, List<Scene> m_scene)
+        {
+            stats_default_page_values returnstruct = new stats_default_page_values();
+            returnstruct.all_scenes = m_scene.ToArray();
+            lock (db)
+            {
+                string SQL = @"SELECT COUNT(DISTINCT agent_id) as agents, COUNT(*) as sessions, AVG(avg_fps) as client_fps, 
+                                AVG(avg_sim_fps) as savg_sim_fps, AVG(avg_ping) as sav_ping, SUM(n_out_kb) as num_in_kb, 
+                                SUM(n_out_pk) as num_in_packets, SUM(n_in_kb) as num_out_kb, SUM(n_in_pk) as num_out_packets, AVG(mem_use) as sav_mem_use
+                                FROM stats_session_data;";
+                SqliteCommand cmd = new SqliteCommand(SQL, db);
+                SqliteDataReader sdr = cmd.ExecuteReader();
+                if (sdr.HasRows)
+                {
+                    sdr.Read();
+                    returnstruct.total_num_users = Convert.ToInt32(sdr["agents"]);
+                    returnstruct.total_num_sessions = Convert.ToInt32(sdr["sessions"]);
+                    returnstruct.avg_client_fps = Convert.ToSingle(sdr["client_fps"]);
+                    returnstruct.avg_sim_fps = Convert.ToSingle(sdr["savg_sim_fps"]);
+                    returnstruct.avg_ping = Convert.ToSingle(sdr["sav_ping"]);
+                    returnstruct.total_kb_out = Convert.ToSingle(sdr["num_out_kb"]);
+                    returnstruct.total_kb_in = Convert.ToSingle(sdr["num_in_kb"]);
+                    returnstruct.avg_client_mem_use = Convert.ToSingle(sdr["sav_mem_use"]);
+
+                }
+            }
+            return returnstruct;
+        }
+
+        /// <summary>
+        /// Return summar information in the form:
+        /// <pre>
+        /// {"totalUsers": "34",
+        ///  "totalSessions": "233",
+        ///  ...
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult) {
+            stats_default_page_values values = (stats_default_page_values) pModelResult["hdata"];
+
+            OSDMap summaryInfo = new OSDMap();
+            summaryInfo.Add("totalUsers", new OSDString(values.total_num_users.ToString()));
+            summaryInfo.Add("totalSessions", new OSDString(values.total_num_sessions.ToString()));
+            summaryInfo.Add("averageClientFPS", new OSDString(values.avg_client_fps.ToString()));
+            summaryInfo.Add("averageClientMem", new OSDString(values.avg_client_mem_use.ToString()));
+            summaryInfo.Add("averageSimFPS", new OSDString(values.avg_sim_fps.ToString()));
+            summaryInfo.Add("averagePingTime", new OSDString(values.avg_ping.ToString()));
+            summaryInfo.Add("totalKBOut", new OSDString(values.total_kb_out.ToString()));
+            summaryInfo.Add("totalKBIn", new OSDString(values.total_kb_in.ToString()));
+            return summaryInfo.ToString();
+        }
+    }
+
+    public struct stats_default_page_values
+    {
+        public int total_num_users;
+        public int total_num_sessions;
+        public float avg_client_fps;
+        public float avg_client_mem_use;
+        public float avg_sim_fps;
+        public float avg_ping;
+        public float total_kb_out;
+        public float total_kb_in;
+        public float avg_client_resends;
+        public Scene[] all_scenes;
+        public Dictionary<UUID, USimStatsData> sim_stat_data;
+        public Dictionary<string, IStatsController> stats_reports;
+    }
+ 
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/HTMLUtil.cs b/OpenSim/Region/OptionalModules/UserStatistics/HTMLUtil.cs
new file mode 100644
index 0000000..c07619f
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/HTMLUtil.cs
@@ -0,0 +1,263 @@
+/*
+ * 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.Region.UserStatistics
+{
+    public static class HTMLUtil
+    {
+
+        public static void TR_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<tr");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(">\n\t");
+        }
+
+        public static void TR_C(ref StringBuilder o)
+        {
+            o.Append("</tr>\n");
+        }
+
+        public static void TD_O(ref StringBuilder o, string pclass)
+        {
+            TD_O(ref o, pclass, 0, 0);
+        }
+
+        public static void TD_O(ref StringBuilder o, string pclass, int rowspan, int colspan)
+        {
+            o.Append("<td");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            if (rowspan > 1)
+            {
+                o.Append(" rowspan=\"");
+                o.Append(rowspan);
+                o.Append("\"");
+            }
+            if (colspan > 1)
+            {
+                o.Append(" colspan=\"");
+                o.Append(colspan);
+                o.Append("\"");
+            }
+            o.Append(">");
+        }
+
+        public static void TD_C(ref StringBuilder o)
+        {
+            o.Append("</td>");
+        }
+
+        public static void TABLE_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<table");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(">\n\t");
+        }
+
+        public static void TABLE_C(ref StringBuilder o)
+        {
+            o.Append("</table>\n");
+        }
+        
+        public static void BLOCKQUOTE_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<blockquote");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void BLOCKQUOTE_C(ref StringBuilder o)
+        {
+            o.Append("</blockquote>\n");
+        }
+
+        public static void BR(ref StringBuilder o)
+        {
+            o.Append("<br />\n");
+        }
+
+        public static void HR(ref StringBuilder o, string pclass)
+        {
+            o.Append("<hr");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void UL_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<ul");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void UL_C(ref StringBuilder o)
+        {
+            o.Append("</ul>\n");
+        }
+
+        public static void OL_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<ol");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void OL_C(ref StringBuilder o)
+        {
+            o.Append("</ol>\n");
+        }
+
+        public static void LI_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<li");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void LI_C(ref StringBuilder o)
+        {
+            o.Append("</li>\n");
+        }
+
+        public static void GenericClass(ref StringBuilder o, string pclass)
+        {
+            o.Append(" class=\"");
+            o.Append(pclass);
+            o.Append("\"");
+        }
+
+        public static void InsertProtoTypeAJAX(ref StringBuilder o)
+        {
+            o.Append("<script type=\"text/javascript\" src=\"prototype.js\"></script>\n");
+            o.Append("<script type=\"text/javascript\" src=\"updater.js\"></script>\n");
+        }
+
+        public static void InsertPeriodicUpdaters(ref StringBuilder o, string[] divID, int[] seconds, string[] reportfrag)
+        {
+            o.Append("<script type=\"text/javascript\">\n");
+            o.Append(
+                @"
+                // <![CDATA[
+                document.observe('dom:loaded', function() {
+                    /*
+                    first arg    : div to update
+                    second arg    : interval to poll in seconds
+                    third arg    : file to get data
+                    */
+");
+            for (int i = 0; i < divID.Length; i++)
+            {
+            
+                o.Append("new updater('");
+                o.Append(divID[i]);
+                o.Append("', ");
+                o.Append(seconds[i]);
+                o.Append(", '");
+                o.Append(reportfrag[i]);
+                o.Append("');\n");
+            }
+
+            o.Append(@"
+                });
+                // ]]>
+                </script>");
+        }
+
+        public static void HtmlHeaders_O(ref StringBuilder o)
+        {
+            o.Append("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n");
+            o.Append("<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"nl\">");
+            o.Append("<head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-1\" />");
+        }
+
+        public static void HtmlHeaders_C(ref StringBuilder o)
+        {
+            o.Append("</HEAD>");
+            o.Append("<BODY>");
+        }
+
+        public static void AddReportLinks(ref StringBuilder o, Dictionary<string, IStatsController> reports, string pClass)
+        {
+            int repcount = 0;
+            foreach (string str in reports.Keys)
+            {
+                if (reports[str].ReportName.Length > 0)
+                {
+                    if (repcount > 0)
+                    {
+                        o.Append("|&nbsp;&nbsp;");
+                    }
+                    A(ref o, reports[str].ReportName, str, pClass);
+                    o.Append("&nbsp;&nbsp;");
+                    repcount++;
+                }
+            }
+        }
+
+        public static void A(ref StringBuilder o, string linktext, string linkhref, string pClass)
+        {
+            o.Append("<A");
+            if (pClass.Length > 0)
+            {
+                GenericClass(ref o, pClass);
+            }
+            o.Append(" href=\"");
+            o.Append(linkhref);
+            o.Append("\">");
+            o.Append(linktext);
+            o.Append("</A>");
+        }
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/IStatsReport.cs b/OpenSim/Region/OptionalModules/UserStatistics/IStatsReport.cs
new file mode 100644
index 0000000..80c4487
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/IStatsReport.cs
@@ -0,0 +1,39 @@
+/*
+ * 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.Collections;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public interface IStatsController
+    {
+        string ReportName { get; }
+        Hashtable ProcessModel(Hashtable pParams);
+        string RenderView(Hashtable pModelResult);
+        string RenderJson(Hashtable pModelResult);
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/LogLinesAJAX.cs b/OpenSim/Region/OptionalModules/UserStatistics/LogLinesAJAX.cs
new file mode 100644
index 0000000..4d45b80
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/LogLinesAJAX.cs
@@ -0,0 +1,159 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class LogLinesAJAX : IStatsController
+    {
+        private Regex normalizeEndLines = new Regex(@"\r\n", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.Multiline);
+
+        private Regex webFormat = new Regex(@"[^\s]*\s([^,]*),[^\s]*\s([A-Z]*)[^\s-][^\[]*\[([^\]]*)\]([^\n]*)",
+                                            RegexOptions.Singleline | RegexOptions.Compiled);
+        private Regex TitleColor = new Regex(@"[^\s]*\s(?:[^,]*),[^\s]*\s(?:[A-Z]*)[^\s-][^\[]*\[([^\]]*)\](?:[^\n]*)",
+                                    RegexOptions.Singleline | RegexOptions.Compiled);
+
+
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            Hashtable nh = new Hashtable();
+            nh.Add("loglines", pParams["LogLines"]);
+            return nh;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            StringBuilder output = new StringBuilder();
+            
+            HTMLUtil.HR(ref output, "");
+            output.Append("<H3>ActiveLog</H3>\n");
+
+            string tmp = normalizeEndLines.Replace(pModelResult["loglines"].ToString(), "\n");
+
+            string[] result = Regex.Split(tmp, "\n");
+
+            string formatopen = "";
+            string formatclose = "";
+
+            for (int i = 0; i < result.Length; i++)
+            {
+                if (result[i].Length >= 30)
+                {
+                    string logtype = result[i].Substring(24, 6);
+                    switch (logtype)
+                    {
+                        case "WARN  ":
+                            formatopen = "<font color=\"#7D7C00\">";
+                            formatclose = "</font>";
+                            break;
+
+                        case "ERROR ":
+                            formatopen = "<font color=\"#FF0000\">";
+                            formatclose = "</font>";
+                            break;
+
+                        default:
+                            formatopen = "";
+                            formatclose = "";
+                            break;
+
+                    }
+                }
+                StringBuilder replaceStr = new StringBuilder();
+                //string titlecolorresults = 
+                
+                string formatresult = Regex.Replace(TitleColor.Replace(result[i], "$1"), "[^ABCDEFabcdef0-9]", "");
+                if (formatresult.Length > 6)
+                {
+                    formatresult = formatresult.Substring(0, 6);
+                   
+                }
+                for (int j = formatresult.Length; j <= 5; j++)
+                    formatresult += "0";
+                replaceStr.Append("$1 - [<font color=\"#");
+                replaceStr.Append(formatresult);
+                replaceStr.Append("\">$3</font>] $4<br />");
+                string repstr = replaceStr.ToString();
+                
+                output.Append(formatopen);
+                output.Append(webFormat.Replace(result[i], repstr));
+                output.Append(formatclose);
+            }
+                
+
+            return output.ToString();
+        }
+
+        /// <summary>
+        /// Return the last log lines. Output in the format:
+        /// <pre>
+        /// {"logLines": [
+        /// "line1",
+        /// "line2",
+        /// ...
+        /// ]
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult)
+        {
+            OSDMap logInfo = new OpenMetaverse.StructuredData.OSDMap();
+
+            OSDArray logLines = new OpenMetaverse.StructuredData.OSDArray();
+            string tmp = normalizeEndLines.Replace(pModelResult["loglines"].ToString(), "\n");
+            string[] result = Regex.Split(tmp, "\n");
+            for (int i = 0; i < result.Length; i++)
+            {
+                logLines.Add(new OSDString(result[i]));
+            }
+            logInfo.Add("logLines", logLines);
+            return logInfo.ToString();
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Prototype_distributor.cs b/OpenSim/Region/OptionalModules/UserStatistics/Prototype_distributor.cs
new file mode 100644
index 0000000..6f8b2aa
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Prototype_distributor.cs
@@ -0,0 +1,80 @@
+/*
+ * 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.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Prototype_distributor : IStatsController
+    {
+        private string jsFileName = "prototype.js";
+        private string prototypejs = string.Empty;
+
+        public Prototype_distributor()
+        {
+            jsFileName = "prototype.js";
+        }
+
+        public Prototype_distributor(string jsName) 
+        {
+            jsFileName = jsName;
+        }
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            Hashtable pResult = new Hashtable();
+            pResult["js"] = jsFileName;
+            return pResult;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            string fileName = (string)pModelResult["js"];
+            using (StreamReader fs = new StreamReader(new FileStream(Util.dataDir() + "/data/" + fileName, FileMode.Open)))
+            {
+                prototypejs = fs.ReadToEnd();
+                fs.Close();
+            }
+            return prototypejs;
+        }
+
+        public string RenderJson(Hashtable pModelResult)
+        {
+            return "{}";
+        }
+
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Sessions_Report.cs b/OpenSim/Region/OptionalModules/UserStatistics/Sessions_Report.cs
new file mode 100644
index 0000000..0e94912
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Sessions_Report.cs
@@ -0,0 +1,288 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Sessions_Report : IStatsController
+    {
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return "Sessions"; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            Hashtable modeldata = new Hashtable();
+            modeldata.Add("Scenes", pParams["Scenes"]);
+            modeldata.Add("Reports", pParams["Reports"]);
+            SqliteConnection dbConn = (SqliteConnection)pParams["DatabaseConnection"];
+            List<SessionList> lstSessions = new List<SessionList>();
+            Hashtable requestvars = (Hashtable) pParams["RequestVars"];
+            
+
+            string puserUUID = string.Empty;
+            string clientVersionString = string.Empty;
+            int queryparams = 0;
+
+            if (requestvars != null)
+            {
+                if (requestvars.ContainsKey("UserID"))
+                {
+                    UUID testUUID = UUID.Zero;
+                    if (UUID.TryParse(requestvars["UserID"].ToString(), out testUUID))
+                    {
+                        puserUUID = requestvars["UserID"].ToString();
+
+                    }
+                }
+
+                if (requestvars.ContainsKey("VersionString"))
+                {
+                    clientVersionString = requestvars["VersionString"].ToString();
+                }
+            }
+
+            lock (dbConn)
+            {
+                string sql =
+                    "SELECT distinct a.name_f, a.name_l, a.Agent_ID, b.Session_ID, b.client_version, b.last_updated, b.start_time FROM stats_session_data a LEFT OUTER JOIN stats_session_data b ON a.Agent_ID = b.Agent_ID";
+
+                if (puserUUID.Length > 0)
+                {
+                    if (queryparams == 0)
+                        sql += " WHERE";
+                    else
+                        sql += " AND";
+
+                    sql += " b.agent_id=:agent_id";
+                    queryparams++;
+                }
+
+                if (clientVersionString.Length > 0)
+                {
+                    if (queryparams == 0)
+                        sql += " WHERE";
+                    else
+                        sql += " AND";
+
+                    sql += " b.client_version=:client_version";
+                    queryparams++;
+                }
+
+                sql += " ORDER BY a.name_f, a.name_l, b.last_updated;";
+
+                SqliteCommand cmd = new SqliteCommand(sql, dbConn);
+
+                if (puserUUID.Length > 0)
+                    cmd.Parameters.Add(new SqliteParameter(":agent_id", puserUUID));
+                if (clientVersionString.Length > 0)
+                    cmd.Parameters.Add(new SqliteParameter(":client_version", clientVersionString));
+
+                SqliteDataReader sdr = cmd.ExecuteReader();
+                
+                if (sdr.HasRows)
+                {
+                    UUID userUUID = UUID.Zero;
+
+                    SessionList activeSessionList = new SessionList();
+                    activeSessionList.user_id=UUID.Random();
+                    while (sdr.Read())
+                    {
+                        UUID readUUID = UUID.Parse(sdr["agent_id"].ToString());
+                        if (readUUID != userUUID)
+                        {
+                            activeSessionList = new SessionList();
+                            activeSessionList.user_id = readUUID;
+                            activeSessionList.firstname = sdr["name_f"].ToString();
+                            activeSessionList.lastname = sdr["name_l"].ToString();
+                            activeSessionList.sessions = new List<ShortSessionData>();
+                            lstSessions.Add(activeSessionList);
+                        }
+
+                        ShortSessionData ssd = new ShortSessionData();
+                        
+                        ssd.last_update = Utils.UnixTimeToDateTime((uint)Convert.ToInt32(sdr["last_updated"]));
+                        ssd.start_time = Utils.UnixTimeToDateTime((uint)Convert.ToInt32(sdr["start_time"]));
+                        ssd.session_id = UUID.Parse(sdr["session_id"].ToString());
+                        ssd.client_version = sdr["client_version"].ToString();
+                        activeSessionList.sessions.Add(ssd);
+
+                        userUUID = activeSessionList.user_id;
+                    }
+                }
+                sdr.Close();
+                sdr.Dispose();
+                
+            }
+            modeldata["SessionData"] = lstSessions;
+            return modeldata;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            List<SessionList> lstSession = (List<SessionList>) pModelResult["SessionData"];
+            Dictionary<string, IStatsController> reports = (Dictionary<string, IStatsController>)pModelResult["Reports"];
+
+            const string STYLESHEET =
+    @"
+<STYLE>
+body
+{
+    font-size:15px; font-family:Helvetica, Verdana; color:Black;
+}
+TABLE.defaultr { }
+TR.defaultr { padding: 5px; }
+TD.header { font-weight:bold; padding:5px; }
+TD.content {}
+TD.contentright { text-align: right; }
+TD.contentcenter { text-align: center; }
+TD.align_top { vertical-align: top; }
+</STYLE>
+";
+
+            StringBuilder output = new StringBuilder();
+            HTMLUtil.HtmlHeaders_O(ref output);
+            output.Append(STYLESHEET);
+            HTMLUtil.HtmlHeaders_C(ref output);
+
+            HTMLUtil.AddReportLinks(ref output, reports, "");
+
+            HTMLUtil.TABLE_O(ref output, "defaultr");
+            HTMLUtil.TR_O(ref output, "defaultr");
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("FirstName");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("LastName");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("SessionEnd");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("SessionLength");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("Client");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+            if (lstSession.Count == 0)
+            {
+                HTMLUtil.TR_O(ref output, "");
+                HTMLUtil.TD_O(ref output, "align_top", 1, 5);
+                output.Append("No results for that query");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+            }
+            foreach (SessionList ssnlst in lstSession)
+            {
+                int cnt = 0;
+                foreach (ShortSessionData sesdata in ssnlst.sessions)
+                {
+                    HTMLUtil.TR_O(ref output, "");
+                    if (cnt++ == 0)
+                    {
+                        HTMLUtil.TD_O(ref output, "align_top", ssnlst.sessions.Count, 1);
+                        output.Append(ssnlst.firstname);
+                        HTMLUtil.TD_C(ref output);
+                        HTMLUtil.TD_O(ref output, "align_top", ssnlst.sessions.Count, 1);
+                        output.Append(ssnlst.lastname);
+                        HTMLUtil.TD_C(ref output);
+                    }
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(sesdata.last_update.ToShortDateString());
+                    output.Append(" - ");
+                    output.Append(sesdata.last_update.ToShortTimeString());
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    TimeSpan dtlength = sesdata.last_update.Subtract(sesdata.start_time);
+                    if (dtlength.Days > 0)
+                    {
+                        output.Append(dtlength.Days);
+                        output.Append(" Days ");
+                    }
+                    if (dtlength.Hours > 0)
+                    {
+                        output.Append(dtlength.Hours);
+                        output.Append(" Hours ");
+                    }
+                    if (dtlength.Minutes > 0)
+                    {
+                        output.Append(dtlength.Minutes);
+                        output.Append(" Minutes");
+                    }
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(sesdata.client_version);
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TR_C(ref output);
+                    
+                }
+                HTMLUtil.TR_O(ref output, "");
+                HTMLUtil.TD_O(ref output, "align_top", 1, 5);
+                HTMLUtil.HR(ref output, "");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+            }
+            HTMLUtil.TABLE_C(ref output);
+            output.Append("</BODY>\n</HTML>");
+            return output.ToString();
+        }
+
+        public class SessionList
+        {
+            public string firstname;
+            public string lastname;
+            public UUID user_id;
+            public List<ShortSessionData> sessions;
+        }
+
+        public struct ShortSessionData
+        {
+            public UUID session_id;
+            public string client_version;
+            public DateTime last_update;
+            public DateTime start_time;
+        }
+
+        public string RenderJson(Hashtable pModelResult)
+        {
+            return "{}";
+        }
+        #endregion
+    }
+
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/SimStatsAJAX.cs b/OpenSim/Region/OptionalModules/UserStatistics/SimStatsAJAX.cs
new file mode 100644
index 0000000..06d9e91
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/SimStatsAJAX.cs
@@ -0,0 +1,276 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class SimStatsAJAX : IStatsController
+    {
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            List<Scene> m_scene = (List<Scene>)pParams["Scenes"];
+            
+            Hashtable nh = new Hashtable();
+            nh.Add("hdata", m_scene);
+            nh.Add("simstats", pParams["SimStats"]);
+            return nh;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            StringBuilder output = new StringBuilder();
+            List<Scene> all_scenes = (List<Scene>) pModelResult["hdata"];
+            Dictionary<UUID, USimStatsData> sdatadic = (Dictionary<UUID,USimStatsData>)pModelResult["simstats"];
+
+            const string TableClass = "defaultr";
+            const string TRClass = "defaultr";
+            const string TDHeaderClass = "header";
+            const string TDDataClass = "content";
+            //const string TDDataClassRight = "contentright";
+            const string TDDataClassCenter = "contentcenter";
+
+            foreach (USimStatsData sdata in sdatadic.Values)
+            {
+
+
+                foreach (Scene sn in all_scenes)
+                {
+                    if (sn.RegionInfo.RegionID == sdata.RegionId)
+                    {
+                        output.Append("<H2>");
+                        output.Append(sn.RegionInfo.RegionName);
+                        output.Append("</H2>");
+                    }
+                }
+                HTMLUtil.TABLE_O(ref output, TableClass);
+                HTMLUtil.TR_O(ref output, TRClass);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("Dilatn");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("SimFPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("PhysFPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("AgntUp");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("RootAg");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("ChldAg");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("Prims");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("ATvPrm");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("AtvScr");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("ScrLPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+                HTMLUtil.TR_O(ref output, TRClass);
+                HTMLUtil.TD_O(ref output, TDDataClass);
+                output.Append(sdata.TimeDilation);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClass);
+                output.Append(sdata.SimFps);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.PhysicsFps);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.AgentUpdates);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.RootAgents);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.ChildAgents);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.TotalPrims);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.ActivePrims);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.ActiveScripts);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.ScriptLinesPerSecond);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+                HTMLUtil.TR_O(ref output, TRClass);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("FrmMS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("AgtMS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("PhysMS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("OthrMS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("OutPPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("InPPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("NoAckKB");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("PndDWN");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("PndUP");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+                HTMLUtil.TR_O(ref output, TRClass);
+                HTMLUtil.TD_O(ref output, TDDataClass);
+                output.Append(sdata.TotalFrameTime);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClass);
+                output.Append(sdata.AgentFrameTime);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.PhysicsFrameTime);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.OtherFrameTime);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.OutPacketsPerSecond);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.InPacketsPerSecond);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.UnackedBytes);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.PendingDownloads);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.PendingUploads);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+                HTMLUtil.TABLE_C(ref output);
+                
+            }
+            
+            return output.ToString();
+        }
+
+        /// <summary>
+        /// Return stat information for all regions in the sim. Returns data of the form:
+        /// <pre>
+        /// {"REGIONNAME": {
+        ///     "region": "REGIONNAME",
+        ///     "timeDilation": "101", 
+        ///     ...     // the rest of the stat info
+        ///     },
+        ///  ...    // entries for each region
+        ///  }
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult)
+        {
+            List<Scene> all_scenes = (List<Scene>) pModelResult["hdata"];
+            Dictionary<UUID, USimStatsData> sdatadic = (Dictionary<UUID,USimStatsData>)pModelResult["simstats"];
+
+            OSDMap allStatsInfo = new OpenMetaverse.StructuredData.OSDMap();
+            foreach (USimStatsData sdata in sdatadic.Values)
+            {
+                OSDMap statsInfo = new OpenMetaverse.StructuredData.OSDMap();
+                string regionName = "unknown";
+                foreach (Scene sn in all_scenes)
+                {
+                    if (sn.RegionInfo.RegionID == sdata.RegionId)
+                    {
+                        regionName = sn.RegionInfo.RegionName;
+                        break;
+                    }
+                }
+                statsInfo.Add("region", new OSDString(regionName));
+                statsInfo.Add("timeDilation", new OSDString(sdata.TimeDilation.ToString()));
+                statsInfo.Add("simFPS", new OSDString(sdata.SimFps.ToString()));
+                statsInfo.Add("physicsFPS", new OSDString(sdata.PhysicsFps.ToString()));
+                statsInfo.Add("agentUpdates", new OSDString(sdata.AgentUpdates.ToString()));
+                statsInfo.Add("rootAgents", new OSDString(sdata.RootAgents.ToString()));
+                statsInfo.Add("childAgents", new OSDString(sdata.ChildAgents.ToString()));
+                statsInfo.Add("totalPrims", new OSDString(sdata.TotalPrims.ToString()));
+                statsInfo.Add("activePrims", new OSDString(sdata.ActivePrims.ToString()));
+                statsInfo.Add("activeScripts", new OSDString(sdata.ActiveScripts.ToString()));
+                statsInfo.Add("scriptLinesPerSec", new OSDString(sdata.ScriptLinesPerSecond.ToString()));
+                statsInfo.Add("totalFrameTime", new OSDString(sdata.TotalFrameTime.ToString()));
+                statsInfo.Add("agentFrameTime", new OSDString(sdata.AgentFrameTime.ToString()));
+                statsInfo.Add("physicsFrameTime", new OSDString(sdata.PhysicsFrameTime.ToString()));
+                statsInfo.Add("otherFrameTime", new OSDString(sdata.OtherFrameTime.ToString()));
+                statsInfo.Add("outPacketsPerSec", new OSDString(sdata.OutPacketsPerSecond.ToString()));
+                statsInfo.Add("inPacketsPerSec", new OSDString(sdata.InPacketsPerSecond.ToString()));
+                statsInfo.Add("unackedByptes", new OSDString(sdata.UnackedBytes.ToString()));
+                statsInfo.Add("pendingDownloads", new OSDString(sdata.PendingDownloads.ToString()));
+                statsInfo.Add("pendingUploads", new OSDString(sdata.PendingUploads.ToString()));
+
+                allStatsInfo.Add(regionName, statsInfo);
+            }
+            return allStatsInfo.ToString();
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Updater_distributor.cs b/OpenSim/Region/OptionalModules/UserStatistics/Updater_distributor.cs
new file mode 100644
index 0000000..601e06b
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Updater_distributor.cs
@@ -0,0 +1,70 @@
+/*
+ * 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.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Updater_distributor : IStatsController
+    {
+        private string updaterjs = string.Empty;
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            Hashtable pResult = new Hashtable();
+            if (updaterjs.Length == 0)
+            {
+                StreamReader fs = new StreamReader(new FileStream(Util.dataDir() + "/data/updater.js", FileMode.Open));
+                updaterjs = fs.ReadToEnd();
+                fs.Close();
+                fs.Dispose();
+            }
+            pResult["js"] = updaterjs;
+            return pResult;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            return pModelResult["js"].ToString();
+        }
+
+        public string RenderJson(Hashtable pModelResult) {
+            return "{}";
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/WebStatsModule.cs b/OpenSim/Region/OptionalModules/UserStatistics/WebStatsModule.cs
new file mode 100644
index 0000000..bd5289f
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/WebStatsModule.cs
@@ -0,0 +1,1203 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.IO;
+using System.Net; // to be used for REST-->Grid shortly
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Mono.Data.SqliteClient;
+using Mono.Addins;
+
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+using OSD = OpenMetaverse.StructuredData.OSD;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+namespace OpenSim.Region.UserStatistics
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "WebStatsModule")]
+    public class WebStatsModule : ISharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private static SqliteConnection dbConn;
+
+        /// <summary>
+        /// User statistics sessions keyed by agent ID
+        /// </summary>
+        private Dictionary<UUID, UserSession> m_sessions = new Dictionary<UUID, UserSession>();
+
+        private List<Scene> m_scenes = new List<Scene>();
+        private Dictionary<string, IStatsController> reports = new Dictionary<string, IStatsController>();
+        private Dictionary<UUID, USimStatsData> m_simstatsCounters = new Dictionary<UUID, USimStatsData>(); 
+        private const int updateStatsMod = 6;
+        private int updateLogMod = 1;
+        private volatile int updateLogCounter = 0;
+        private volatile int concurrencyCounter = 0;
+        private bool enabled = false;
+        private string m_loglines = String.Empty;
+        private volatile int lastHit = 12000;
+
+        #region ISharedRegionModule
+
+        public virtual void Initialise(IConfigSource config)
+        {
+            IConfig cnfg = config.Configs["WebStats"];
+
+            if (cnfg != null)
+                enabled = cnfg.GetBoolean("enabled", false);
+        }
+
+        public virtual void PostInitialise()
+        {
+            if (!enabled)
+                return;
+
+            if (Util.IsWindows())
+                Util.LoadArchSpecificWindowsDll("sqlite3.dll");
+
+            //IConfig startupConfig = config.Configs["Startup"];
+
+            dbConn = new SqliteConnection("URI=file:LocalUserStatistics.db,version=3");
+            dbConn.Open();
+            CreateTables(dbConn);
+
+            Prototype_distributor protodep = new Prototype_distributor();
+            Updater_distributor updatedep = new Updater_distributor();
+            ActiveConnectionsAJAX ajConnections = new ActiveConnectionsAJAX();
+            SimStatsAJAX ajSimStats = new SimStatsAJAX();
+            LogLinesAJAX ajLogLines = new LogLinesAJAX();
+            Default_Report defaultReport = new Default_Report();
+            Clients_report clientReport = new Clients_report();
+            Sessions_Report sessionsReport = new Sessions_Report();
+
+            reports.Add("prototype.js", protodep);
+            reports.Add("updater.js", updatedep);
+            reports.Add("activeconnectionsajax.html", ajConnections);
+            reports.Add("simstatsajax.html", ajSimStats);
+            reports.Add("activelogajax.html", ajLogLines);
+            reports.Add("default.report", defaultReport);
+            reports.Add("clients.report", clientReport);
+            reports.Add("sessions.report", sessionsReport);
+
+            reports.Add("sim.css", new Prototype_distributor("sim.css"));
+            reports.Add("sim.html", new Prototype_distributor("sim.html"));
+            reports.Add("jquery.js", new Prototype_distributor("jquery.js"));
+
+            ////
+            // Add Your own Reports here (Do Not Modify Lines here Devs!)
+            ////
+
+            ////
+            // End Own reports section
+            ////
+
+            MainServer.Instance.AddHTTPHandler("/SStats/", HandleStatsRequest);
+            MainServer.Instance.AddHTTPHandler("/CAPS/VS/", HandleUnknownCAPSRequest);
+        }
+
+        public virtual void AddRegion(Scene scene)
+        {
+            if (!enabled)
+                return;
+
+            lock (m_scenes)
+            {
+                m_scenes.Add(scene);
+                updateLogMod = m_scenes.Count * 2;
+
+                m_simstatsCounters.Add(scene.RegionInfo.RegionID, new USimStatsData(scene.RegionInfo.RegionID));
+
+                scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+                scene.EventManager.OnDeregisterCaps += OnDeRegisterCaps;
+                scene.EventManager.OnClientClosed += OnClientClosed;
+                scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
+                scene.StatsReporter.OnSendStatsResult += ReceiveClassicSimStatsPacket;
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!enabled)
+                return;
+
+            lock (m_scenes)
+            {
+                m_scenes.Remove(scene);
+                updateLogMod = m_scenes.Count * 2;
+                m_simstatsCounters.Remove(scene.RegionInfo.RegionID);
+            }
+        }
+
+        public virtual void Close()
+        {
+            if (!enabled)
+                return;
+
+            dbConn.Close();
+            dbConn.Dispose();
+            m_sessions.Clear();
+            m_scenes.Clear();
+            reports.Clear();
+            m_simstatsCounters.Clear();
+        }
+
+        public virtual string Name
+        {
+            get { return "ViewerStatsModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        private void ReceiveClassicSimStatsPacket(SimStats stats)
+        {
+            if (!enabled)
+                return;
+
+            try
+            {
+                // Ignore the update if there's a report running right now
+                // ignore the update if there hasn't been a hit in 30 seconds.
+                if (concurrencyCounter > 0 || System.Environment.TickCount - lastHit > 30000)
+                    return;
+
+                // We will conduct this under lock so that fields such as updateLogCounter do not potentially get
+                // confused if a scene is removed.
+                // XXX: Possibly the scope of this lock could be reduced though it's not critical.
+                lock (m_scenes)
+                {
+                    if (updateLogMod != 0 && updateLogCounter++ % updateLogMod == 0)
+                    {
+                        m_loglines = readLogLines(10);
+
+                        if (updateLogCounter > 10000) 
+                            updateLogCounter = 1;
+                    }
+
+                    USimStatsData ss = m_simstatsCounters[stats.RegionUUID];
+
+                    if ((++ss.StatsCounter % updateStatsMod) == 0)
+                    {
+                        ss.ConsumeSimStats(stats);
+                    }
+                }
+            } 
+            catch (KeyNotFoundException)
+            {
+            }
+        }
+        
+        private Hashtable HandleUnknownCAPSRequest(Hashtable request)
+        {
+            //string regpath = request["uri"].ToString();
+            int response_code = 200;
+            string contenttype = "text/html";
+            UpdateUserStats(ParseViewerStats(request["body"].ToString(), UUID.Zero), dbConn);
+            Hashtable responsedata = new Hashtable();
+
+            responsedata["int_response_code"] = response_code;
+            responsedata["content_type"] = contenttype;
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = string.Empty;
+            return responsedata;
+        }
+
+        private Hashtable HandleStatsRequest(Hashtable request)
+        {
+            lastHit = System.Environment.TickCount;
+            Hashtable responsedata = new Hashtable();
+            string regpath = request["uri"].ToString();
+            int response_code = 404;
+            string contenttype = "text/html";
+            bool jsonFormatOutput = false;
+            
+            string strOut = string.Empty;
+
+            // The request patch should be "/SStats/reportName" where 'reportName'
+            // is one of the names added to the 'reports' hashmap.
+            regpath = regpath.Remove(0, 8);
+            if (regpath.Length == 0) regpath = "default.report";
+            if (reports.ContainsKey(regpath))
+            {
+                IStatsController rep = reports[regpath];
+                Hashtable repParams = new Hashtable();
+
+                if (request.ContainsKey("json"))
+                    jsonFormatOutput = true;
+
+                if (request.ContainsKey("requestvars"))
+                    repParams["RequestVars"] = request["requestvars"];
+                else
+                    repParams["RequestVars"] = new Hashtable();
+
+                if (request.ContainsKey("querystringkeys"))
+                    repParams["QueryStringKeys"] = request["querystringkeys"];
+                else
+                    repParams["QueryStringKeys"] = new string[0];
+
+
+                repParams["DatabaseConnection"] = dbConn;
+                repParams["Scenes"] = m_scenes;
+                repParams["SimStats"] = m_simstatsCounters;
+                repParams["LogLines"] = m_loglines;
+                repParams["Reports"] = reports;
+                
+                concurrencyCounter++;
+
+                if (jsonFormatOutput) 
+                {
+                    strOut = rep.RenderJson(rep.ProcessModel(repParams));
+                    contenttype = "text/json";
+                }
+                else 
+                {
+                    strOut = rep.RenderView(rep.ProcessModel(repParams));
+                }
+
+                if (regpath.EndsWith("js"))
+                {
+                    contenttype = "text/javascript";
+                }
+
+                if (regpath.EndsWith("css"))
+                {
+                    contenttype = "text/css";
+                }
+
+                concurrencyCounter--;
+                
+                response_code = 200;
+            }
+            else
+            {
+                strOut = MainServer.Instance.GetHTTP404("");
+            }
+
+            responsedata["int_response_code"] = response_code;
+            responsedata["content_type"] = contenttype;
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = strOut;
+
+            return responsedata;
+        }
+
+        private void CreateTables(SqliteConnection db)
+        {
+            using (SqliteCommand createcmd = new SqliteCommand(SQL_STATS_TABLE_CREATE, db))
+            {
+                createcmd.ExecuteNonQuery();
+            }
+        }
+
+        private void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+//            m_log.DebugFormat("[WEB STATS MODULE]: OnRegisterCaps: agentID {0} caps {1}", agentID, caps);
+
+            string capsPath = "/CAPS/VS/" + UUID.Random();
+            caps.RegisterHandler(
+                "ViewerStats",
+                new RestStreamHandler(
+                    "POST",
+                    capsPath,
+                    (request, path, param, httpRequest, httpResponse)
+                        => ViewerStatsReport(request, path, param, agentID, caps),
+                    "ViewerStats",
+                    agentID.ToString()));
+        }
+
+        private void OnDeRegisterCaps(UUID agentID, Caps caps)
+        {
+        }
+
+        protected virtual void AddEventHandlers()
+        {
+            lock (m_scenes)
+            {
+                updateLogMod = m_scenes.Count * 2;
+                foreach (Scene scene in m_scenes)
+                {
+                    scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+                    scene.EventManager.OnDeregisterCaps += OnDeRegisterCaps;
+                    scene.EventManager.OnClientClosed += OnClientClosed;
+                    scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
+                }
+            }
+        }
+
+        private void OnMakeRootAgent(ScenePresence agent)
+        {
+//            m_log.DebugFormat(
+//                "[WEB STATS MODULE]: Looking for session {0} for {1} in {2}",
+//                agent.ControllingClient.SessionId, agent.Name, agent.Scene.Name);
+
+            lock (m_sessions)
+            {
+                UserSession uid;
+
+                if (!m_sessions.ContainsKey(agent.UUID))
+                {
+                    UserSessionData usd = UserSessionUtil.newUserSessionData();
+                    uid = new UserSession();
+                    uid.name_f = agent.Firstname;
+                    uid.name_l = agent.Lastname;
+                    uid.session_data = usd;
+
+                    m_sessions.Add(agent.UUID, uid);
+                }
+                else
+                {
+                    uid = m_sessions[agent.UUID];
+                }
+
+                uid.region_id = agent.Scene.RegionInfo.RegionID;
+                uid.session_id = agent.ControllingClient.SessionId;
+            }
+        }
+
+        private void OnClientClosed(UUID agentID, Scene scene)
+        {
+            lock (m_sessions)
+            {
+                if (m_sessions.ContainsKey(agentID) && m_sessions[agentID].region_id == scene.RegionInfo.RegionID)
+                {
+                    m_sessions.Remove(agentID);
+                }
+            }
+        }
+
+        private string readLogLines(int amount)
+        {
+            Encoding encoding = Encoding.ASCII;
+            int sizeOfChar = encoding.GetByteCount("\n");
+            byte[] buffer = encoding.GetBytes("\n");
+            string logfile = Util.logFile();
+            FileStream fs = new FileStream(logfile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            Int64 tokenCount = 0;
+            Int64 endPosition = fs.Length / sizeOfChar;
+
+            for (Int64 position = sizeOfChar; position < endPosition; position += sizeOfChar)
+            {
+                fs.Seek(-position, SeekOrigin.End);
+                fs.Read(buffer, 0, buffer.Length);
+
+                if (encoding.GetString(buffer) == "\n")
+                {
+                    tokenCount++;
+                    if (tokenCount == amount)
+                    {
+                        byte[] returnBuffer = new byte[fs.Length - fs.Position];
+                        fs.Read(returnBuffer, 0, returnBuffer.Length);
+                        fs.Close();
+                        fs.Dispose();
+                        return encoding.GetString(returnBuffer);
+                    }
+                }
+            }
+
+            // handle case where number of tokens in file is less than numberOfTokens
+            fs.Seek(0, SeekOrigin.Begin);
+            buffer = new byte[fs.Length];
+            fs.Read(buffer, 0, buffer.Length);
+            fs.Close();
+            fs.Dispose();
+            return encoding.GetString(buffer);
+        }
+
+        /// <summary>
+        /// Callback for a viewerstats cap
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="agentID"></param>
+        /// <param name="caps"></param>
+        /// <returns></returns>
+        private string ViewerStatsReport(string request, string path, string param,
+                                      UUID agentID, Caps caps)
+        {
+//            m_log.DebugFormat("[WEB STATS MODULE]: Received viewer starts report from {0}", agentID);
+ 
+            UpdateUserStats(ParseViewerStats(request, agentID), dbConn);
+
+            return String.Empty;
+        }
+
+        private UserSession ParseViewerStats(string request, UUID agentID)
+        {
+            UserSession uid = new UserSession();
+            UserSessionData usd;
+            OSD message = OSDParser.DeserializeLLSDXml(request);
+            OSDMap mmap;
+
+            lock (m_sessions)
+            {
+                if (agentID != UUID.Zero)
+                {
+                    if (!m_sessions.ContainsKey(agentID))
+                    {
+                        m_log.WarnFormat("[WEB STATS MODULE]: no session for stat disclosure for agent {0}", agentID);
+                        return new UserSession();
+                    }
+
+                    uid = m_sessions[agentID];
+
+//                    m_log.DebugFormat("[WEB STATS MODULE]: Got session {0} for {1}", uid.session_id, agentID);
+                }
+                else
+                {
+                    // parse through the beginning to locate the session
+                    if (message.Type != OSDType.Map)
+                        return new UserSession();
+
+                    mmap = (OSDMap)message;
+                    {
+                        UUID sessionID = mmap["session_id"].AsUUID();
+
+                        if (sessionID == UUID.Zero)
+                            return new UserSession();
+
+
+                        // search through each session looking for the owner
+                        foreach (UUID usersessionid in m_sessions.Keys)
+                        {
+                            // got it!
+                            if (m_sessions[usersessionid].session_id == sessionID)
+                            {
+                                agentID = usersessionid;
+                                uid = m_sessions[usersessionid];
+                                break;
+                            }
+
+                        }
+
+                        // can't find a session
+                        if (agentID == UUID.Zero)
+                        {
+                            return new UserSession();
+                        }
+                    }
+                }
+            }
+           
+            usd = uid.session_data;
+
+            if (message.Type != OSDType.Map)
+                return new UserSession();
+
+            mmap = (OSDMap)message;
+            {
+                if (mmap["agent"].Type != OSDType.Map)
+                    return new UserSession();
+                OSDMap agent_map = (OSDMap)mmap["agent"];
+                usd.agent_id = agentID;
+                usd.name_f = uid.name_f;
+                usd.name_l = uid.name_l;
+                usd.region_id = uid.region_id;
+                usd.a_language = agent_map["language"].AsString();
+                usd.mem_use = (float)agent_map["mem_use"].AsReal();
+                usd.meters_traveled = (float)agent_map["meters_traveled"].AsReal();
+                usd.regions_visited = agent_map["regions_visited"].AsInteger();
+                usd.run_time = (float)agent_map["run_time"].AsReal();
+                usd.start_time = (float)agent_map["start_time"].AsReal();
+                usd.client_version = agent_map["version"].AsString();
+
+                UserSessionUtil.UpdateMultiItems(ref usd, agent_map["agents_in_view"].AsInteger(),
+                                                 (float)agent_map["ping"].AsReal(),
+                                                 (float)agent_map["sim_fps"].AsReal(),
+                                                 (float)agent_map["fps"].AsReal());
+
+                if (mmap["downloads"].Type != OSDType.Map)
+                    return new UserSession();
+                OSDMap downloads_map = (OSDMap)mmap["downloads"];
+                usd.d_object_kb = (float)downloads_map["object_kbytes"].AsReal();
+                usd.d_texture_kb = (float)downloads_map["texture_kbytes"].AsReal();
+                usd.d_world_kb = (float)downloads_map["workd_kbytes"].AsReal();
+
+//                m_log.DebugFormat("[WEB STATS MODULE]: mmap[\"session_id\"] = [{0}]", mmap["session_id"].AsUUID());
+
+                usd.session_id = mmap["session_id"].AsUUID();
+
+                if (mmap["system"].Type != OSDType.Map)
+                    return new UserSession();
+                OSDMap system_map = (OSDMap)mmap["system"];
+
+                usd.s_cpu = system_map["cpu"].AsString();
+                usd.s_gpu = system_map["gpu"].AsString();
+                usd.s_os = system_map["os"].AsString();
+                usd.s_ram = system_map["ram"].AsInteger();
+
+                if (mmap["stats"].Type != OSDType.Map)
+                    return new UserSession();
+
+                OSDMap stats_map = (OSDMap)mmap["stats"];
+                {
+
+                    if (stats_map["failures"].Type != OSDType.Map)
+                        return new UserSession();
+                    OSDMap stats_failures = (OSDMap)stats_map["failures"];
+                    usd.f_dropped = stats_failures["dropped"].AsInteger();
+                    usd.f_failed_resends = stats_failures["failed_resends"].AsInteger();
+                    usd.f_invalid = stats_failures["invalid"].AsInteger();
+                    usd.f_resent = stats_failures["resent"].AsInteger();
+                    usd.f_send_packet = stats_failures["send_packet"].AsInteger();
+
+                    if (stats_map["net"].Type != OSDType.Map)
+                        return new UserSession();
+                    OSDMap stats_net = (OSDMap)stats_map["net"];
+                    {
+                        if (stats_net["in"].Type != OSDType.Map)
+                            return new UserSession();
+
+                        OSDMap net_in = (OSDMap)stats_net["in"];
+                        usd.n_in_kb = (float)net_in["kbytes"].AsReal();
+                        usd.n_in_pk = net_in["packets"].AsInteger();
+
+                        if (stats_net["out"].Type != OSDType.Map)
+                            return new UserSession();
+                        OSDMap net_out = (OSDMap)stats_net["out"];
+
+                        usd.n_out_kb = (float)net_out["kbytes"].AsReal();
+                        usd.n_out_pk = net_out["packets"].AsInteger();
+                    }
+                }
+            }
+
+            uid.session_data = usd;
+            m_sessions[agentID] = uid;
+
+//            m_log.DebugFormat(
+//                "[WEB STATS MODULE]: Parse data for {0} {1}, session {2}", uid.name_f, uid.name_l, uid.session_id);
+
+            return uid;
+        }
+
+        private void UpdateUserStats(UserSession uid, SqliteConnection db)
+        {
+//            m_log.DebugFormat(
+//                "[WEB STATS MODULE]: Updating user stats for {0} {1}, session {2}", uid.name_f, uid.name_l, uid.session_id);
+
+            if (uid.session_id == UUID.Zero)
+                return;
+
+            lock (db)
+            {
+                using (SqliteCommand updatecmd = new SqliteCommand(SQL_STATS_TABLE_INSERT, db))
+                {
+                    updatecmd.Parameters.Add(new SqliteParameter(":session_id", uid.session_data.session_id.ToString()));
+                    updatecmd.Parameters.Add(new SqliteParameter(":agent_id", uid.session_data.agent_id.ToString()));
+                    updatecmd.Parameters.Add(new SqliteParameter(":region_id", uid.session_data.region_id.ToString()));
+                    updatecmd.Parameters.Add(new SqliteParameter(":last_updated", (int) uid.session_data.last_updated));
+                    updatecmd.Parameters.Add(new SqliteParameter(":remote_ip", uid.session_data.remote_ip));
+                    updatecmd.Parameters.Add(new SqliteParameter(":name_f", uid.session_data.name_f));
+                    updatecmd.Parameters.Add(new SqliteParameter(":name_l", uid.session_data.name_l));
+                    updatecmd.Parameters.Add(new SqliteParameter(":avg_agents_in_view", uid.session_data.avg_agents_in_view));
+                    updatecmd.Parameters.Add(new SqliteParameter(":min_agents_in_view",
+                                                                 (int) uid.session_data.min_agents_in_view));
+                    updatecmd.Parameters.Add(new SqliteParameter(":max_agents_in_view",
+                                                                 (int) uid.session_data.max_agents_in_view));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mode_agents_in_view",
+                                                                 (int) uid.session_data.mode_agents_in_view));
+                    updatecmd.Parameters.Add(new SqliteParameter(":avg_fps", uid.session_data.avg_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":min_fps", uid.session_data.min_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":max_fps", uid.session_data.max_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mode_fps", uid.session_data.mode_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":a_language", uid.session_data.a_language));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mem_use", uid.session_data.mem_use));
+                    updatecmd.Parameters.Add(new SqliteParameter(":meters_traveled", uid.session_data.meters_traveled));
+                    updatecmd.Parameters.Add(new SqliteParameter(":avg_ping", uid.session_data.avg_ping));
+                    updatecmd.Parameters.Add(new SqliteParameter(":min_ping", uid.session_data.min_ping));
+                    updatecmd.Parameters.Add(new SqliteParameter(":max_ping", uid.session_data.max_ping));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mode_ping", uid.session_data.mode_ping));
+                    updatecmd.Parameters.Add(new SqliteParameter(":regions_visited", uid.session_data.regions_visited));
+                    updatecmd.Parameters.Add(new SqliteParameter(":run_time", uid.session_data.run_time));
+                    updatecmd.Parameters.Add(new SqliteParameter(":avg_sim_fps", uid.session_data.avg_sim_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":min_sim_fps", uid.session_data.min_sim_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":max_sim_fps", uid.session_data.max_sim_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mode_sim_fps", uid.session_data.mode_sim_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":start_time", uid.session_data.start_time));
+                    updatecmd.Parameters.Add(new SqliteParameter(":client_version", uid.session_data.client_version));
+                    updatecmd.Parameters.Add(new SqliteParameter(":s_cpu", uid.session_data.s_cpu));
+                    updatecmd.Parameters.Add(new SqliteParameter(":s_gpu", uid.session_data.s_gpu));
+                    updatecmd.Parameters.Add(new SqliteParameter(":s_os", uid.session_data.s_os));
+                    updatecmd.Parameters.Add(new SqliteParameter(":s_ram", uid.session_data.s_ram));
+                    updatecmd.Parameters.Add(new SqliteParameter(":d_object_kb", uid.session_data.d_object_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":d_texture_kb", uid.session_data.d_texture_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":d_world_kb", uid.session_data.d_world_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":n_in_kb", uid.session_data.n_in_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":n_in_pk", uid.session_data.n_in_pk));
+                    updatecmd.Parameters.Add(new SqliteParameter(":n_out_kb", uid.session_data.n_out_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":n_out_pk", uid.session_data.n_out_pk));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_dropped", uid.session_data.f_dropped));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_failed_resends", uid.session_data.f_failed_resends));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_invalid", uid.session_data.f_invalid));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_off_circuit", uid.session_data.f_off_circuit));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_resent", uid.session_data.f_resent));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_send_packet", uid.session_data.f_send_packet));
+
+//                        StringBuilder parameters = new StringBuilder();
+//                        SqliteParameterCollection spc = updatecmd.Parameters;
+//                        foreach (SqliteParameter sp in spc)
+//                            parameters.AppendFormat("{0}={1},", sp.ParameterName, sp.Value);
+//
+//                        m_log.DebugFormat("[WEB STATS MODULE]: Parameters {0}", parameters);
+
+//                    m_log.DebugFormat("[WEB STATS MODULE]: Database stats update for {0}", uid.session_data.agent_id);
+
+                    updatecmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        #region SQL
+        private const string SQL_STATS_TABLE_CREATE = @"CREATE TABLE IF NOT EXISTS stats_session_data (
+               session_id VARCHAR(36) NOT NULL PRIMARY KEY,
+               agent_id VARCHAR(36) NOT NULL DEFAULT '',
+               region_id VARCHAR(36) NOT NULL DEFAULT '',
+               last_updated INT NOT NULL DEFAULT '0',
+               remote_ip VARCHAR(16) NOT NULL DEFAULT '',
+               name_f VARCHAR(50) NOT NULL DEFAULT '',
+               name_l VARCHAR(50) NOT NULL DEFAULT '',
+               avg_agents_in_view FLOAT NOT NULL DEFAULT '0',
+               min_agents_in_view INT NOT NULL DEFAULT '0',
+               max_agents_in_view INT NOT NULL DEFAULT '0',
+               mode_agents_in_view INT NOT NULL DEFAULT '0',
+               avg_fps FLOAT NOT NULL DEFAULT '0',
+               min_fps FLOAT NOT NULL DEFAULT '0',
+               max_fps FLOAT NOT NULL DEFAULT '0',
+               mode_fps FLOAT NOT NULL DEFAULT '0',
+               a_language VARCHAR(25) NOT NULL DEFAULT '',
+               mem_use FLOAT NOT NULL DEFAULT '0',
+               meters_traveled FLOAT NOT NULL DEFAULT '0',
+               avg_ping FLOAT NOT NULL DEFAULT '0',
+               min_ping FLOAT NOT NULL DEFAULT '0',
+               max_ping FLOAT NOT NULL DEFAULT '0',
+               mode_ping FLOAT NOT NULL DEFAULT '0',
+               regions_visited INT NOT NULL DEFAULT '0',
+               run_time FLOAT NOT NULL DEFAULT '0',
+               avg_sim_fps FLOAT NOT NULL DEFAULT '0',
+               min_sim_fps FLOAT NOT NULL DEFAULT '0',
+               max_sim_fps FLOAT NOT NULL DEFAULT '0',
+               mode_sim_fps FLOAT NOT NULL DEFAULT '0',
+               start_time FLOAT NOT NULL DEFAULT '0',
+               client_version VARCHAR(255) NOT NULL DEFAULT '',
+               s_cpu VARCHAR(255) NOT NULL DEFAULT '',
+               s_gpu VARCHAR(255) NOT NULL DEFAULT '',
+               s_os VARCHAR(2255) NOT NULL DEFAULT '',
+               s_ram INT NOT NULL DEFAULT '0',
+               d_object_kb FLOAT NOT NULL DEFAULT '0',
+               d_texture_kb FLOAT NOT NULL DEFAULT '0',
+               d_world_kb FLOAT NOT NULL DEFAULT '0',
+               n_in_kb FLOAT NOT NULL DEFAULT '0',
+               n_in_pk INT NOT NULL DEFAULT '0',
+               n_out_kb FLOAT NOT NULL DEFAULT '0',
+               n_out_pk INT NOT NULL DEFAULT '0',
+               f_dropped INT NOT NULL DEFAULT '0',
+               f_failed_resends INT NOT NULL DEFAULT '0',
+               f_invalid INT NOT NULL DEFAULT '0',
+               f_off_circuit INT NOT NULL DEFAULT '0',
+               f_resent INT NOT NULL DEFAULT '0',
+               f_send_packet INT NOT NULL DEFAULT '0'
+            );";
+
+        private const string SQL_STATS_TABLE_INSERT = @"INSERT OR REPLACE INTO stats_session_data (
+session_id, agent_id, region_id, last_updated, remote_ip, name_f, name_l, avg_agents_in_view, min_agents_in_view, max_agents_in_view, 
+mode_agents_in_view, avg_fps, min_fps, max_fps, mode_fps, a_language, mem_use, meters_traveled, avg_ping, min_ping, max_ping, mode_ping, 
+regions_visited, run_time, avg_sim_fps, min_sim_fps, max_sim_fps, mode_sim_fps, start_time, client_version, s_cpu, s_gpu, s_os, s_ram,
+d_object_kb, d_texture_kb, d_world_kb, n_in_kb, n_in_pk, n_out_kb, n_out_pk, f_dropped, f_failed_resends, f_invalid, f_off_circuit,
+f_resent, f_send_packet
+)
+VALUES
+(
+:session_id, :agent_id, :region_id, :last_updated, :remote_ip, :name_f, :name_l, :avg_agents_in_view, :min_agents_in_view, :max_agents_in_view, 
+:mode_agents_in_view, :avg_fps, :min_fps, :max_fps, :mode_fps, :a_language, :mem_use, :meters_traveled, :avg_ping, :min_ping, :max_ping, :mode_ping, 
+:regions_visited, :run_time, :avg_sim_fps, :min_sim_fps, :max_sim_fps, :mode_sim_fps, :start_time, :client_version, :s_cpu, :s_gpu, :s_os, :s_ram,
+:d_object_kb, :d_texture_kb, :d_world_kb, :n_in_kb, :n_in_pk, :n_out_kb, :n_out_pk, :f_dropped, :f_failed_resends, :f_invalid, :f_off_circuit,
+:f_resent, :f_send_packet
+)
+";
+
+    #endregion
+
+    }
+
+    public static class UserSessionUtil
+    {
+        public static UserSessionData newUserSessionData()
+        {
+            UserSessionData obj = ZeroSession(new UserSessionData());
+            return obj;
+        }
+
+        public static void UpdateMultiItems(ref UserSessionData s, int agents_in_view, float ping, float sim_fps, float fps)
+        {
+            // don't insert zero values here or it'll skew the statistics.
+            if (agents_in_view == 0 && fps == 0 && sim_fps == 0 && ping == 0)
+                return;
+            s._agents_in_view.Add(agents_in_view);
+            s._fps.Add(fps);
+            s._sim_fps.Add(sim_fps);
+            s._ping.Add(ping);
+
+            int[] __agents_in_view = s._agents_in_view.ToArray();
+
+            s.avg_agents_in_view = ArrayAvg_i(__agents_in_view);
+            s.min_agents_in_view = ArrayMin_i(__agents_in_view);
+            s.max_agents_in_view = ArrayMax_i(__agents_in_view);
+            s.mode_agents_in_view = ArrayMode_i(__agents_in_view);
+
+            float[] __fps = s._fps.ToArray();
+            s.avg_fps = ArrayAvg_f(__fps);
+            s.min_fps = ArrayMin_f(__fps);
+            s.max_fps = ArrayMax_f(__fps);
+            s.mode_fps = ArrayMode_f(__fps);
+
+            float[] __sim_fps = s._sim_fps.ToArray();
+            s.avg_sim_fps = ArrayAvg_f(__sim_fps);
+            s.min_sim_fps = ArrayMin_f(__sim_fps);
+            s.max_sim_fps = ArrayMax_f(__sim_fps);
+            s.mode_sim_fps = ArrayMode_f(__sim_fps);
+
+            float[] __ping = s._ping.ToArray();
+            s.avg_ping = ArrayAvg_f(__ping);
+            s.min_ping = ArrayMin_f(__ping);
+            s.max_ping = ArrayMax_f(__ping);
+            s.mode_ping = ArrayMode_f(__ping);
+        }
+
+        #region Statistics
+
+        public static int ArrayMin_i(int[] arr)
+        {
+            int cnt = arr.Length;
+            if (cnt == 0)
+                return 0;
+
+            Array.Sort(arr);
+            return arr[0];
+        }
+
+        public static int ArrayMax_i(int[] arr)
+        {
+            int cnt = arr.Length;
+            if (cnt == 0)
+                return 0;
+
+            Array.Sort(arr);
+            return arr[cnt-1];
+        }
+
+        public static float ArrayMin_f(float[] arr)
+        {
+            int cnt = arr.Length;
+            if (cnt == 0)
+                return 0;
+
+            Array.Sort(arr);
+            return arr[0];
+        }
+
+        public static float ArrayMax_f(float[] arr)
+        {
+            int cnt = arr.Length;
+            if (cnt == 0)
+                return 0;
+
+            Array.Sort(arr);
+            return arr[cnt - 1];
+        }
+
+        public static float ArrayAvg_i(int[] arr)
+        {
+            int cnt = arr.Length;
+
+            if (cnt == 0)
+                return 0;
+
+            float result = arr[0];
+
+            for (int i = 1; i < cnt; i++)
+                result += arr[i];
+
+            return result / cnt;
+        }
+
+        public static float ArrayAvg_f(float[] arr)
+        {
+            int cnt = arr.Length;
+
+            if (cnt == 0)
+                return 0;
+
+            float result = arr[0];
+
+            for (int i = 1; i < cnt; i++)
+                result += arr[i];
+
+            return result / cnt;
+        }
+
+        public static float ArrayMode_f(float[] arr)
+        {
+            List<float> mode = new List<float>();
+
+            float[] srtArr = new float[arr.Length];
+            float[,] freq = new float[arr.Length, 2];
+            Array.Copy(arr, srtArr, arr.Length);
+            Array.Sort(srtArr);
+
+            float tmp = srtArr[0];
+            int index = 0;
+            int i = 0;
+            while (i < srtArr.Length)
+            {
+                freq[index, 0] = tmp;
+
+                while (tmp == srtArr[i])
+                {
+                    freq[index, 1]++;
+                    i++;
+
+                    if (i > srtArr.Length - 1)
+                        break;
+                }
+
+                if (i < srtArr.Length)
+                {
+                    tmp = srtArr[i];
+                    index++;
+                }
+
+            }
+
+            Array.Clear(srtArr, 0, srtArr.Length);
+
+            for (i = 0; i < srtArr.Length; i++)
+                srtArr[i] = freq[i, 1];
+
+            Array.Sort(srtArr);
+
+            if ((srtArr[srtArr.Length - 1]) == 0 || (srtArr[srtArr.Length - 1]) == 1)
+                return 0;
+
+            float freqtest = (float)freq.Length / freq.Rank;
+
+            for (i = 0; i < freqtest; i++)
+            {
+                if (freq[i, 1] == srtArr[index])
+                    mode.Add(freq[i, 0]);
+
+            }
+
+            return mode.ToArray()[0];
+        }
+
+        public static int ArrayMode_i(int[] arr)
+        {
+            List<int> mode = new List<int>();
+
+            int[] srtArr = new int[arr.Length];
+            int[,] freq = new int[arr.Length, 2];
+            Array.Copy(arr, srtArr, arr.Length);
+            Array.Sort(srtArr);
+
+            int tmp = srtArr[0];
+            int index = 0;
+            int i = 0;
+            while (i < srtArr.Length)
+            {
+                freq[index, 0] = tmp;
+
+                while (tmp == srtArr[i])
+                {
+                    freq[index, 1]++;
+                    i++;
+
+                    if (i > srtArr.Length - 1)
+                        break;
+                }
+
+                if (i < srtArr.Length)
+                {
+                    tmp = srtArr[i];
+                    index++;
+                }
+
+            }
+
+            Array.Clear(srtArr, 0, srtArr.Length);
+
+            for (i = 0; i < srtArr.Length; i++)
+                srtArr[i] = freq[i, 1];
+
+            Array.Sort(srtArr);
+
+            if ((srtArr[srtArr.Length - 1]) == 0 || (srtArr[srtArr.Length - 1]) == 1)
+                return 0;
+           
+            float freqtest = (float)freq.Length / freq.Rank;
+
+            for (i = 0; i < freqtest; i++)
+            {
+                if (freq[i, 1] == srtArr[index])
+                    mode.Add(freq[i, 0]);
+
+            }
+
+            return mode.ToArray()[0];
+        }
+
+        #endregion
+
+        private static UserSessionData ZeroSession(UserSessionData s)
+        {
+            s.session_id = UUID.Zero;
+            s.agent_id = UUID.Zero;
+            s.region_id = UUID.Zero;
+            s.last_updated = Util.UnixTimeSinceEpoch();
+            s.remote_ip = "";
+            s.name_f = "";
+            s.name_l = "";
+            s.avg_agents_in_view = 0;
+            s.min_agents_in_view = 0;
+            s.max_agents_in_view = 0;
+            s.mode_agents_in_view = 0;
+            s.avg_fps = 0;
+            s.min_fps = 0;
+            s.max_fps = 0;
+            s.mode_fps = 0;
+            s.a_language = "";
+            s.mem_use = 0;
+            s.meters_traveled = 0;
+            s.avg_ping = 0;
+            s.min_ping = 0;
+            s.max_ping = 0;
+            s.mode_ping = 0;
+            s.regions_visited = 0;
+            s.run_time = 0;
+            s.avg_sim_fps = 0;
+            s.min_sim_fps = 0;
+            s.max_sim_fps = 0;
+            s.mode_sim_fps = 0;
+            s.start_time = 0;
+            s.client_version = "";
+            s.s_cpu = "";
+            s.s_gpu = "";
+            s.s_os = "";
+            s.s_ram = 0;
+            s.d_object_kb = 0;
+            s.d_texture_kb = 0;
+            s.d_world_kb = 0;
+            s.n_in_kb = 0;
+            s.n_in_pk = 0;
+            s.n_out_kb = 0;
+            s.n_out_pk = 0;
+            s.f_dropped = 0;
+            s.f_failed_resends = 0;
+            s.f_invalid = 0;
+            s.f_off_circuit = 0;
+            s.f_resent = 0;
+            s.f_send_packet = 0;
+            s._ping = new List<float>();
+            s._fps = new List<float>();
+            s._sim_fps = new List<float>();
+            s._agents_in_view = new List<int>();
+            return s;
+        }
+    }
+    #region structs
+
+    public class UserSession
+    {
+        public UUID session_id;
+        public UUID region_id;
+        public string name_f;
+        public string name_l;
+        public UserSessionData session_data;
+    }
+
+    public struct UserSessionData
+    {
+        public UUID session_id;
+        public UUID agent_id;
+        public UUID region_id;
+        public float last_updated;
+        public string remote_ip;
+        public string name_f;
+        public string name_l;
+        public float avg_agents_in_view;
+        public float min_agents_in_view;
+        public float max_agents_in_view;
+        public float mode_agents_in_view;
+        public float avg_fps;
+        public float min_fps;
+        public float max_fps;
+        public float mode_fps;
+        public string a_language;
+        public float mem_use;
+        public float meters_traveled;
+        public float avg_ping;
+        public float min_ping;
+        public float max_ping;
+        public float mode_ping;
+        public int regions_visited;
+        public float run_time;
+        public float avg_sim_fps;
+        public float min_sim_fps;
+        public float max_sim_fps;
+        public float mode_sim_fps;
+        public float start_time;
+        public string client_version;
+        public string s_cpu;
+        public string s_gpu;
+        public string s_os;
+        public int s_ram;
+        public float d_object_kb;
+        public float d_texture_kb;
+        public float d_world_kb;
+        public float n_in_kb;
+        public int n_in_pk;
+        public float n_out_kb;
+        public int n_out_pk;
+        public int f_dropped;
+        public int f_failed_resends;
+        public int f_invalid;
+        public int f_off_circuit;
+        public int f_resent;
+        public int f_send_packet;
+        public List<float> _ping;
+        public List<float> _fps;
+        public List<float> _sim_fps;
+        public List<int> _agents_in_view;
+    }
+  
+    #endregion
+
+    public class USimStatsData
+    {
+        private UUID m_regionID = UUID.Zero;
+        private volatile int m_statcounter = 0;
+        private volatile float m_timeDilation;
+        private volatile float m_simFps;
+        private volatile float m_physicsFps;
+        private volatile float m_agentUpdates;
+        private volatile float m_rootAgents;
+        private volatile float m_childAgents;
+        private volatile float m_totalPrims;
+        private volatile float m_activePrims;
+        private volatile float m_totalFrameTime;
+        private volatile float m_netFrameTime;
+        private volatile float m_physicsFrameTime;
+        private volatile float m_otherFrameTime;
+        private volatile float m_imageFrameTime;
+        private volatile float m_inPacketsPerSecond;
+        private volatile float m_outPacketsPerSecond;
+        private volatile float m_unackedBytes;
+        private volatile float m_agentFrameTime;
+        private volatile float m_pendingDownloads;
+        private volatile float m_pendingUploads;
+        private volatile float m_activeScripts;
+        private volatile float m_scriptLinesPerSecond;
+
+        public UUID RegionId { get { return m_regionID; } }
+        public int StatsCounter { get { return m_statcounter; } set { m_statcounter = value;}}
+        public float TimeDilation { get { return m_timeDilation; } }
+        public float SimFps { get { return m_simFps; } }
+        public float PhysicsFps { get { return m_physicsFps; } }
+        public float AgentUpdates { get { return m_agentUpdates; } }
+        public float RootAgents { get { return m_rootAgents; } }
+        public float ChildAgents { get { return m_childAgents; } }
+        public float TotalPrims { get { return m_totalPrims; } }
+        public float ActivePrims { get { return m_activePrims; } }
+        public float TotalFrameTime { get { return m_totalFrameTime; } }
+        public float NetFrameTime { get { return m_netFrameTime; } }
+        public float PhysicsFrameTime { get { return m_physicsFrameTime; } }
+        public float OtherFrameTime { get { return m_otherFrameTime; } }
+        public float ImageFrameTime { get { return m_imageFrameTime; } }
+        public float InPacketsPerSecond { get { return m_inPacketsPerSecond; } }
+        public float OutPacketsPerSecond { get { return m_outPacketsPerSecond; } }
+        public float UnackedBytes { get { return m_unackedBytes; } }
+        public float AgentFrameTime { get { return m_agentFrameTime; } }
+        public float PendingDownloads { get { return m_pendingDownloads; } }
+        public float PendingUploads { get { return m_pendingUploads; } }
+        public float ActiveScripts { get { return m_activeScripts; } }
+        public float ScriptLinesPerSecond { get { return m_scriptLinesPerSecond; } }
+
+        public USimStatsData(UUID pRegionID)
+        {
+            m_regionID = pRegionID;
+        }
+
+        public void ConsumeSimStats(SimStats stats)
+        {
+            m_regionID = stats.RegionUUID;
+            m_timeDilation = stats.StatsBlock[0].StatValue;
+            m_simFps = stats.StatsBlock[1].StatValue;
+            m_physicsFps = stats.StatsBlock[2].StatValue;
+            m_agentUpdates = stats.StatsBlock[3].StatValue;
+            m_rootAgents = stats.StatsBlock[4].StatValue;
+            m_childAgents = stats.StatsBlock[5].StatValue;
+            m_totalPrims = stats.StatsBlock[6].StatValue;
+            m_activePrims = stats.StatsBlock[7].StatValue;
+            m_totalFrameTime = stats.StatsBlock[8].StatValue;
+            m_netFrameTime = stats.StatsBlock[9].StatValue;
+            m_physicsFrameTime = stats.StatsBlock[10].StatValue;
+            m_otherFrameTime = stats.StatsBlock[11].StatValue;
+            m_imageFrameTime = stats.StatsBlock[12].StatValue;
+            m_inPacketsPerSecond = stats.StatsBlock[13].StatValue;
+            m_outPacketsPerSecond = stats.StatsBlock[14].StatValue;
+            m_unackedBytes = stats.StatsBlock[15].StatValue;
+            m_agentFrameTime = stats.StatsBlock[16].StatValue;
+            m_pendingDownloads = stats.StatsBlock[17].StatValue;
+            m_pendingUploads = stats.StatsBlock[18].StatValue;
+            m_activeScripts = stats.StatsBlock[19].StatValue;
+            m_scriptLinesPerSecond = stats.ExtraStatsBlock[0].StatValue;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/World/NPC/Tests/NPCModuleTests.cs b/OpenSim/Region/OptionalModules/World/NPC/Tests/NPCModuleTests.cs
index 2345e38..a892cf4 100644
--- a/OpenSim/Region/OptionalModules/World/NPC/Tests/NPCModuleTests.cs
+++ b/OpenSim/Region/OptionalModules/World/NPC/Tests/NPCModuleTests.cs
@@ -33,7 +33,6 @@ using Nini.Config;
 using NUnit.Framework;
 using OpenMetaverse;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Region.CoreModules.Avatar.Attachments;
 using OpenSim.Region.CoreModules.Avatar.AvatarFactory;
 using OpenSim.Region.CoreModules.Framework.InventoryAccess;